| /* ------------------------------------------------------------------ |
| * 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 |
