diff options
Diffstat (limited to 'media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp')
| -rw-r--r-- | media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp | 421 |
1 files changed, 0 insertions, 421 deletions
diff --git a/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp b/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp deleted file mode 100644 index e2761eb..0000000 --- a/media/libstagefright/codecs/m4v_h263/dec/src/adaptive_smooth_no_mmx.cpp +++ /dev/null @@ -1,421 +0,0 @@ -/* ------------------------------------------------------------------ - * 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 |