/* ------------------------------------------------------------------ * Copyright (C) 1998-2009 PacketVideo * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. * See the License for the specific language governing permissions * and limitations under the License. * ------------------------------------------------------------------- */ /* Description: Separated modules into one function per file and put into new template. Description: Optimizing C code and adding comments. Also changing variable names to make them more meaningful. Who: Date: Description: ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: Rec_Y = pointer to 0th position in buffer containing luminance values of type uint8. y_start = value of y coordinate of type int that specifies the first row of pixels to be used in the filter algorithm. x_start = value of x coordinate of type int that specifies the first column of pixels to be used in the filter algorithm. y_blk_start = value of the y coordinate of type int that specifies the row of pixels which contains the start of a block. The row specified by y_blk_start+BLK_SIZE is the last row of pixels that are used in the filter algorithm. x_blk_start = value of the x coordinate of type int that specifies the column of pixels which contains the start of a block. The column specified by x_blk_start+BLK_SIZE is the last column of pixels that are used in the filter algorithm. thr = value of type int that is compared to the elements in Rec_Y to determine if a particular value in Rec_Y will be modified by the filter or not width = value of type int that specifies the width of the display in pixels (or pels, equivalently). max_diff = value of type int that specifies the value that may be added or subtracted from the pixel in Rec_Y that is being filtered if the filter algorithm decides to change that particular pixel's luminance value. Local Stores/Buffers/Pointers Needed: None Global Stores/Buffers/Pointers Needed: None Outputs: None Pointers and Buffers Modified: Buffer pointed to by Rec_Y is modified with the filtered luminance values. Local Stores Modified: None Global Stores Modified: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION This function implements a motion compensated noise filter using adaptive weighted averaging of luminance values. *Rec_Y contains the luminance values that are being filtered. The picture below depicts a 3x3 group of pixel luminance values. The "u", "c", and "l" stand for "upper", "center" and "lower", respectively. The location of pelc0 is specified by x_start and y_start in the 1-D array "Rec_Y" as follows (assuming x_start=0): location of pelc0 = [(y_start+1) * width] + x_start Moving up or down 1 row (moving from pelu2 to pelc2, for example) is done by incrementing or decrementing "width" elements within Rec_Y. The coordinates of the upper left hand corner of a block (not the group of 9 pixels depicted in the figure below) is specified by (y_blk_start, x_blk_start). The width and height of the block is BLKSIZE. (y_start,x_start) may be specified independently of (y_blk_start, x_blk_start). (y_start,x_start) -----------|-------------------------- | | | | | | X | pelu1 | pelu2 | | pelu0 | | | | | | | -------------------------------------- | | | | | pelc0 | pelc1 | pelc2 | | | | | | | | | -------------------------------------- | | | | | pell0 | pell1 | pell2 | | | | | | | | | -------------------------------------- The filtering of the luminance values is achieved by comparing the 9 luminance values to a threshold value ("thr") and then changing the luminance value of pelc1 if all of the values are above or all of the values are below the threshold. The amount that the luminance value is changed depends on a weighted sum of the 9 luminance values. The position of Pelc1 is then advanced to the right by one (as well as all of the surrounding pixels) and the same calculation is performed again for the luminance value of the new Pelc1. This continues row-wise until pixels in the last row of the block are filtered. ------------------------------------------------------------------------------ REQUIREMENTS None. ------------------------------------------------------------------------------ REFERENCES ..\corelibs\decoder\common\src\post_proc.c ------------------------------------------------------------------------------ PSEUDO-CODE ------------------------------------------------------------------------------ RESOURCES USED When the code is written for a specific target processor the the resources used should be documented below. STACK USAGE: [stack count for this module] + [variable to represent stack usage for each subroutine called] where: [stack usage variable] = stack usage for [subroutine name] (see [filename].ext) DATA MEMORY USED: x words PROGRAM MEMORY USED: x words CLOCK CYCLES: [cycle count equation for this module] + [variable used to represent cycle count for each subroutine called] where: [cycle count variable] = cycle count for [subroutine name] (see [filename].ext) ------------------------------------------------------------------------------ */ /*---------------------------------------------------------------------------- ; INCLUDES ----------------------------------------------------------------------------*/ #include "mp4dec_lib.h" #include "post_proc.h" #include "mp4def.h" #define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA /*---------------------------------------------------------------------------- ; MACROS ; Define module specific macros here ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; DEFINES ; Include all pre-processor statements here. Include conditional ; compile variables also. ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL FUNCTION DEFINITIONS ; Function Prototype declaration ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL STORE/BUFFER/POINTER DEFINITIONS ; Variable declaration - defined here and used outside this module ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; EXTERNAL FUNCTION REFERENCES ; Declare functions defined elsewhere and referenced in this module ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES ; Declare variables used in this module but defined elsewhere ----------------------------------------------------------------------------*/ #ifdef PV_POSTPROC_ON /*---------------------------------------------------------------------------- ; FUNCTION CODE ----------------------------------------------------------------------------*/ void AdaptiveSmooth_NoMMX( uint8 *Rec_Y, /* i/o */ int y_start, /* i */ int x_start, /* i */ int y_blk_start, /* i */ int x_blk_start, /* i */ int thr, /* i */ int width, /* i */ int max_diff /* i */ ) { /*---------------------------------------------------------------------------- ; Define all local variables ----------------------------------------------------------------------------*/ int sign_v[15]; int sum_v[15]; int *sum_V_ptr; int *sign_V_ptr; uint8 pelu; uint8 pelc; uint8 pell; uint8 *pelp; uint8 oldrow[15]; int sum; int sum1; uint8 *Rec_Y_ptr; int32 addr_v; int row_cntr; int col_cntr; /*---------------------------------------------------------------------------- ; Function body here ----------------------------------------------------------------------------*/ /* first row */ addr_v = (int32)(y_start + 1) * width; /* y coord of 1st element in the row / /containing pelc pixel / */ Rec_Y_ptr = &Rec_Y[addr_v + x_start]; /* initializing pointer to / pelc0 position */ sum_V_ptr = &sum_v[0]; /* initializing pointer to 0th element of array / that will contain weighted sums of pixel / luminance values */ sign_V_ptr = &sign_v[0]; /* initializing pointer to 0th element of / array that will contain sums that indicate / how many of the 9 pixels are above or below / the threshold value (thr) */ pelp = &oldrow[0]; /* initializing pointer to the 0th element of array / that will contain current values of pelc that / are saved and used as values of pelu when the / next row of pixels are filtered */ pelu = *(Rec_Y_ptr - width); /* assigning value of pelu0 to pelu */ *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc0 to pelc and / storing this value in pelp which / will be used as value of pelu0 when / next row is filtered */ pell = *(Rec_Y_ptr + width); /* assigning value of pell0 to pell */ Rec_Y_ptr++; /* advancing pointer from pelc0 to pelc1 */ *sum_V_ptr++ = pelu + (pelc << 1) + pell; /* weighted sum of pelu0, / pelc0 and pell0 */ /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value /is above thr) */ *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); pelu = *(Rec_Y_ptr - width); /* assigning value of pelu1 to pelu */ *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc1 to pelc and / storing this value in pelp which / will be used as the value of pelu1 when / next row is filtered */ pell = *(Rec_Y_ptr + width); /* assigning value of pell1 to pell */ Rec_Y_ptr++; /* advancing pointer from pelc1 to pelc2 */ *sum_V_ptr++ = pelu + (pelc << 1) + pell; /* weighted sum of pelu1, / pelc1 and pell1 */ /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value /is above thr) */ *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); /* The loop below performs the filtering for the first row of / pixels in the region. It steps across the remaining pixels in / the row and alters the luminance value of pelc1 if necessary, / depending on the luminance values of the adjacent pixels*/ for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--) { pelu = *(Rec_Y_ptr - width); /* assigning value of pelu2 to / pelu */ *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc2 to pelc / and storing this value in pelp / which will be used as value of pelu2 / when next row is filtered */ pell = *(Rec_Y_ptr + width); /* assigning value of pell2 to pell */ /* weighted sum of pelu1, pelc1 and pell1 */ *sum_V_ptr = pelu + (pelc << 1) + pell; /* sum of 0's and 1's (0 if pixel value is below thr, /1 if value is above thr) */ *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); /* the value of sum1 indicates how many of the 9 pixels' /luminance values are above or equal to thr */ sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr; /* alter the luminance value of pelc1 if all 9 luminance values /are above or equal to thr or if all 9 values are below thr */ if (sum1 == 0 || sum1 == 9) { /* sum is a weighted average of the 9 pixel luminance /values */ sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) + *sum_V_ptr + 8) >> 4; Rec_Y_ptr--; /* move pointer back to pelc1 */ /* If luminance value of pelc1 is larger than / sum by more than max_diff, then subract max_diff / from luminance value of pelc1*/ if ((int)(*Rec_Y_ptr - sum) > max_diff) { sum = *Rec_Y_ptr - max_diff; } /* If luminance value of pelc1 is smaller than / sum by more than max_diff, then add max_diff / to luminance value of pelc1*/ else if ((int)(*Rec_Y_ptr - sum) < -max_diff) { sum = *Rec_Y_ptr + max_diff; } *Rec_Y_ptr++ = sum; /* assign value of sum to pelc1 and advance pointer to pelc2 */ } Rec_Y_ptr++; /* advance pointer to new value of pelc2 / old pelc2 is now treated as pelc1*/ sum_V_ptr++; /* pointer is advanced so next weighted sum may / be saved */ sign_V_ptr++; /* pointer is advanced so next sum of 0's and / 1's may be saved */ } /* The nested loops below perform the filtering for the remaining rows */ addr_v = (y_start + 2) * width; /* advance addr_v to the next row / (corresponding to pell0)*/ /* The outer loop steps throught the rows. */ for (row_cntr = (y_blk_start + BLKSIZE) - (y_start + 2); row_cntr > 0; row_cntr--) { Rec_Y_ptr = &Rec_Y[addr_v + x_start]; /* advance pointer to /the old pell0, which has become the new pelc0 */ addr_v += width; /* move addr_v down 1 row */ sum_V_ptr = &sum_v[0]; /* re-initializing pointer */ sign_V_ptr = &sign_v[0]; /* re-initilaizing pointer */ pelp = &oldrow[0]; /* re-initializing pointer */ pelu = *pelp; /* setting pelu0 to old value of pelc0 */ *pelp++ = pelc = *Rec_Y_ptr; pell = *(Rec_Y_ptr + width); Rec_Y_ptr++; *sum_V_ptr++ = pelu + (pelc << 1) + pell; *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); pelu = *pelp; /* setting pelu1 to old value of pelc1 */ *pelp++ = pelc = *Rec_Y_ptr; pell = *(Rec_Y_ptr + width); Rec_Y_ptr++; *sum_V_ptr++ = pelu + (pelc << 1) + pell; *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); /* The inner loop steps through the columns */ for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--) { pelu = *pelp; /* setting pelu2 to old value of pelc2 */ *pelp++ = pelc = *Rec_Y_ptr; pell = *(Rec_Y_ptr + width); *sum_V_ptr = pelu + (pelc << 1) + pell; *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr; /* the "if" statement below is the same as the one in / the first loop */ if (sum1 == 0 || sum1 == 9) { sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) + *sum_V_ptr + 8) >> 4; Rec_Y_ptr--; if ((int)(*Rec_Y_ptr - sum) > max_diff) { sum = *Rec_Y_ptr - max_diff; } else if ((int)(*Rec_Y_ptr - sum) < -max_diff) { sum = *Rec_Y_ptr + max_diff; } *Rec_Y_ptr++ = (uint8) sum; } Rec_Y_ptr++; sum_V_ptr++; sign_V_ptr++; } } /*---------------------------------------------------------------------------- ; Return nothing or data or data pointer ----------------------------------------------------------------------------*/ return; } #endif