adaptive_smooth_no_mmx.cpp revision 3306cfee3bf38ab207a0504e49c2d492bb73ffbf
1/* ------------------------------------------------------------------ 2 * Copyright (C) 1998-2009 PacketVideo 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 13 * express or implied. 14 * See the License for the specific language governing permissions 15 * and limitations under the License. 16 * ------------------------------------------------------------------- 17 */ 18/* 19 20 Description: Separated modules into one function per file and put into 21 new template. 22 23 Description: Optimizing C code and adding comments. Also changing variable 24 names to make them more meaningful. 25 26 Who: Date: 27 Description: 28 29------------------------------------------------------------------------------ 30 INPUT AND OUTPUT DEFINITIONS 31 32 Inputs: 33 34 Rec_Y = pointer to 0th position in buffer containing luminance values 35 of type uint8. 36 y_start = value of y coordinate of type int that specifies the first 37 row of pixels to be used in the filter algorithm. 38 x_start = value of x coordinate of type int that specifies the first 39 column of pixels to be used in the filter algorithm. 40 y_blk_start = value of the y coordinate of type int that specifies the 41 row of pixels which contains the start of a block. The row 42 specified by y_blk_start+BLK_SIZE is the last row of pixels 43 that are used in the filter algorithm. 44 x_blk_start = value of the x coordinate of type int that specifies the 45 column of pixels which contains the start of a block. The 46 column specified by x_blk_start+BLK_SIZE is the last column of 47 pixels that are used in the filter algorithm. 48 thr = value of type int that is compared to the elements in Rec_Y to 49 determine if a particular value in Rec_Y will be modified by 50 the filter or not 51 width = value of type int that specifies the width of the display 52 in pixels (or pels, equivalently). 53 max_diff = value of type int that specifies the value that may be added 54 or subtracted from the pixel in Rec_Y that is being filtered 55 if the filter algorithm decides to change that particular 56 pixel's luminance value. 57 58 59 Local Stores/Buffers/Pointers Needed: 60 None 61 62 Global Stores/Buffers/Pointers Needed: 63 None 64 65 Outputs: 66 None 67 68 Pointers and Buffers Modified: 69 Buffer pointed to by Rec_Y is modified with the filtered 70 luminance values. 71 72 Local Stores Modified: 73 None 74 75 Global Stores Modified: 76 None 77 78------------------------------------------------------------------------------ 79 FUNCTION DESCRIPTION 80 81 This function implements a motion compensated noise filter using adaptive 82 weighted averaging of luminance values. *Rec_Y contains the luminance values 83 that are being filtered. 84 85 The picture below depicts a 3x3 group of pixel luminance values. The "u", "c", 86 and "l" stand for "upper", "center" and "lower", respectively. The location 87 of pelc0 is specified by x_start and y_start in the 1-D array "Rec_Y" as 88 follows (assuming x_start=0): 89 90 location of pelc0 = [(y_start+1) * width] + x_start 91 92 Moving up or down 1 row (moving from pelu2 to pelc2, for example) is done by 93 incrementing or decrementing "width" elements within Rec_Y. 94 95 The coordinates of the upper left hand corner of a block (not the group of 96 9 pixels depicted in the figure below) is specified by 97 (y_blk_start, x_blk_start). The width and height of the block is BLKSIZE. 98 (y_start,x_start) may be specified independently of (y_blk_start, x_blk_start). 99 100 (y_start,x_start) 101 -----------|-------------------------- 102 | | | | | 103 | X | pelu1 | pelu2 | 104 | pelu0 | | | 105 | | | | 106 -------------------------------------- 107 | | | | 108 | pelc0 | pelc1 | pelc2 | 109 | | | | 110 | | | | 111 -------------------------------------- 112 | | | | 113 | pell0 | pell1 | pell2 | 114 | | | | 115 | | | | 116 -------------------------------------- 117 118 The filtering of the luminance values is achieved by comparing the 9 119 luminance values to a threshold value ("thr") and then changing the 120 luminance value of pelc1 if all of the values are above or all of the values 121 are below the threshold. The amount that the luminance value is changed 122 depends on a weighted sum of the 9 luminance values. The position of Pelc1 123 is then advanced to the right by one (as well as all of the surrounding pixels) 124 and the same calculation is performed again for the luminance value of the new 125 Pelc1. This continues row-wise until pixels in the last row of the block are 126 filtered. 127 128 129------------------------------------------------------------------------------ 130 REQUIREMENTS 131 132 None. 133 134------------------------------------------------------------------------------ 135 REFERENCES 136 137 ..\corelibs\decoder\common\src\post_proc.c 138 139------------------------------------------------------------------------------ 140 PSEUDO-CODE 141 142------------------------------------------------------------------------------ 143 RESOURCES USED 144 When the code is written for a specific target processor the 145 the resources used should be documented below. 146 147 STACK USAGE: [stack count for this module] + [variable to represent 148 stack usage for each subroutine called] 149 150 where: [stack usage variable] = stack usage for [subroutine 151 name] (see [filename].ext) 152 153 DATA MEMORY USED: x words 154 155 PROGRAM MEMORY USED: x words 156 157 CLOCK CYCLES: [cycle count equation for this module] + [variable 158 used to represent cycle count for each subroutine 159 called] 160 161 where: [cycle count variable] = cycle count for [subroutine 162 name] (see [filename].ext) 163 164------------------------------------------------------------------------------ 165*/ 166 167 168/*---------------------------------------------------------------------------- 169; INCLUDES 170----------------------------------------------------------------------------*/ 171#include "mp4dec_lib.h" 172#include "post_proc.h" 173#include "mp4def.h" 174 175#define OSCL_DISABLE_WARNING_CONV_POSSIBLE_LOSS_OF_DATA 176 177/*---------------------------------------------------------------------------- 178; MACROS 179; Define module specific macros here 180----------------------------------------------------------------------------*/ 181 182 183/*---------------------------------------------------------------------------- 184; DEFINES 185; Include all pre-processor statements here. Include conditional 186; compile variables also. 187----------------------------------------------------------------------------*/ 188 189/*---------------------------------------------------------------------------- 190; LOCAL FUNCTION DEFINITIONS 191; Function Prototype declaration 192----------------------------------------------------------------------------*/ 193 194/*---------------------------------------------------------------------------- 195; LOCAL STORE/BUFFER/POINTER DEFINITIONS 196; Variable declaration - defined here and used outside this module 197----------------------------------------------------------------------------*/ 198 199/*---------------------------------------------------------------------------- 200; EXTERNAL FUNCTION REFERENCES 201; Declare functions defined elsewhere and referenced in this module 202----------------------------------------------------------------------------*/ 203 204/*---------------------------------------------------------------------------- 205; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES 206; Declare variables used in this module but defined elsewhere 207----------------------------------------------------------------------------*/ 208#ifdef PV_POSTPROC_ON 209/*---------------------------------------------------------------------------- 210; FUNCTION CODE 211----------------------------------------------------------------------------*/ 212void AdaptiveSmooth_NoMMX( 213 uint8 *Rec_Y, /* i/o */ 214 int y_start, /* i */ 215 int x_start, /* i */ 216 int y_blk_start, /* i */ 217 int x_blk_start, /* i */ 218 int thr, /* i */ 219 int width, /* i */ 220 int max_diff /* i */ 221) 222{ 223 224 /*---------------------------------------------------------------------------- 225 ; Define all local variables 226 ----------------------------------------------------------------------------*/ 227 int sign_v[15]; 228 int sum_v[15]; 229 int *sum_V_ptr; 230 int *sign_V_ptr; 231 uint8 pelu; 232 uint8 pelc; 233 uint8 pell; 234 uint8 *pelp; 235 uint8 oldrow[15]; 236 int sum; 237 int sum1; 238 uint8 *Rec_Y_ptr; 239 int32 addr_v; 240 int row_cntr; 241 int col_cntr; 242 243 /*---------------------------------------------------------------------------- 244 ; Function body here 245 ----------------------------------------------------------------------------*/ 246 /* first row 247 */ 248 addr_v = (int32)(y_start + 1) * width; /* y coord of 1st element in the row / 249 /containing pelc pixel / */ 250 Rec_Y_ptr = &Rec_Y[addr_v + x_start]; /* initializing pointer to 251 / pelc0 position */ 252 sum_V_ptr = &sum_v[0]; /* initializing pointer to 0th element of array 253 / that will contain weighted sums of pixel 254 / luminance values */ 255 sign_V_ptr = &sign_v[0]; /* initializing pointer to 0th element of 256 / array that will contain sums that indicate 257 / how many of the 9 pixels are above or below 258 / the threshold value (thr) */ 259 pelp = &oldrow[0]; /* initializing pointer to the 0th element of array 260 / that will contain current values of pelc that 261 / are saved and used as values of pelu when the 262 / next row of pixels are filtered */ 263 264 pelu = *(Rec_Y_ptr - width); /* assigning value of pelu0 to pelu */ 265 *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc0 to pelc and 266 / storing this value in pelp which 267 / will be used as value of pelu0 when 268 / next row is filtered */ 269 pell = *(Rec_Y_ptr + width); /* assigning value of pell0 to pell */ 270 Rec_Y_ptr++; /* advancing pointer from pelc0 to pelc1 */ 271 *sum_V_ptr++ = pelu + (pelc << 1) + pell; /* weighted sum of pelu0, 272 / pelc0 and pell0 */ 273 /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value 274 /is above thr) */ 275 *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); 276 277 278 pelu = *(Rec_Y_ptr - width); /* assigning value of pelu1 to pelu */ 279 *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc1 to pelc and 280 / storing this value in pelp which 281 / will be used as the value of pelu1 when 282 / next row is filtered */ 283 pell = *(Rec_Y_ptr + width); /* assigning value of pell1 to pell */ 284 Rec_Y_ptr++; /* advancing pointer from pelc1 to pelc2 */ 285 *sum_V_ptr++ = pelu + (pelc << 1) + pell; /* weighted sum of pelu1, 286 / pelc1 and pell1 */ 287 /* sum of 0's and 1's (0 if pixel value is below thr, 1 if value 288 /is above thr) */ 289 *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + INDEX(pell, thr); 290 291 /* The loop below performs the filtering for the first row of 292 / pixels in the region. It steps across the remaining pixels in 293 / the row and alters the luminance value of pelc1 if necessary, 294 / depending on the luminance values of the adjacent pixels*/ 295 296 for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--) 297 { 298 pelu = *(Rec_Y_ptr - width); /* assigning value of pelu2 to 299 / pelu */ 300 *pelp++ = pelc = *Rec_Y_ptr; /* assigning value of pelc2 to pelc 301 / and storing this value in pelp 302 / which will be used as value of pelu2 303 / when next row is filtered */ 304 pell = *(Rec_Y_ptr + width); /* assigning value of pell2 to pell */ 305 306 /* weighted sum of pelu1, pelc1 and pell1 */ 307 *sum_V_ptr = pelu + (pelc << 1) + pell; 308 /* sum of 0's and 1's (0 if pixel value is below thr, 309 /1 if value is above thr) */ 310 *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) + 311 INDEX(pell, thr); 312 /* the value of sum1 indicates how many of the 9 pixels' 313 /luminance values are above or equal to thr */ 314 sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr; 315 316 /* alter the luminance value of pelc1 if all 9 luminance values 317 /are above or equal to thr or if all 9 values are below thr */ 318 if (sum1 == 0 || sum1 == 9) 319 { 320 /* sum is a weighted average of the 9 pixel luminance 321 /values */ 322 sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) + 323 *sum_V_ptr + 8) >> 4; 324 325 Rec_Y_ptr--; /* move pointer back to pelc1 */ 326 /* If luminance value of pelc1 is larger than 327 / sum by more than max_diff, then subract max_diff 328 / from luminance value of pelc1*/ 329 if ((int)(*Rec_Y_ptr - sum) > max_diff) 330 { 331 sum = *Rec_Y_ptr - max_diff; 332 } 333 /* If luminance value of pelc1 is smaller than 334 / sum by more than max_diff, then add max_diff 335 / to luminance value of pelc1*/ 336 else if ((int)(*Rec_Y_ptr - sum) < -max_diff) 337 { 338 sum = *Rec_Y_ptr + max_diff; 339 } 340 *Rec_Y_ptr++ = sum; /* assign value of sum to pelc1 341 and advance pointer to pelc2 */ 342 } 343 Rec_Y_ptr++; /* advance pointer to new value of pelc2 344 / old pelc2 is now treated as pelc1*/ 345 sum_V_ptr++; /* pointer is advanced so next weighted sum may 346 / be saved */ 347 sign_V_ptr++; /* pointer is advanced so next sum of 0's and 348 / 1's may be saved */ 349 } 350 351 /* The nested loops below perform the filtering for the remaining rows */ 352 353 addr_v = (y_start + 2) * width; /* advance addr_v to the next row 354 / (corresponding to pell0)*/ 355 /* The outer loop steps throught the rows. */ 356 for (row_cntr = (y_blk_start + BLKSIZE) - (y_start + 2); row_cntr > 0; row_cntr--) 357 { 358 Rec_Y_ptr = &Rec_Y[addr_v + x_start]; /* advance pointer to 359 /the old pell0, which has become the new pelc0 */ 360 addr_v += width; /* move addr_v down 1 row */ 361 sum_V_ptr = &sum_v[0]; /* re-initializing pointer */ 362 sign_V_ptr = &sign_v[0]; /* re-initilaizing pointer */ 363 pelp = &oldrow[0]; /* re-initializing pointer */ 364 365 pelu = *pelp; /* setting pelu0 to old value of pelc0 */ 366 *pelp++ = pelc = *Rec_Y_ptr; 367 pell = *(Rec_Y_ptr + width); 368 Rec_Y_ptr++; 369 *sum_V_ptr++ = pelu + (pelc << 1) + pell; 370 *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + 371 INDEX(pell, thr); 372 373 pelu = *pelp; /* setting pelu1 to old value of pelc1 */ 374 *pelp++ = pelc = *Rec_Y_ptr; 375 pell = *(Rec_Y_ptr + width); 376 Rec_Y_ptr++; 377 *sum_V_ptr++ = pelu + (pelc << 1) + pell; 378 *sign_V_ptr++ = INDEX(pelu, thr) + INDEX(pelc, thr) + 379 INDEX(pell, thr); 380 /* The inner loop steps through the columns */ 381 for (col_cntr = (x_blk_start + BLKSIZE - 1) - x_start; col_cntr > 0; col_cntr--) 382 { 383 pelu = *pelp; /* setting pelu2 to old value of pelc2 */ 384 *pelp++ = pelc = *Rec_Y_ptr; 385 pell = *(Rec_Y_ptr + width); 386 387 *sum_V_ptr = pelu + (pelc << 1) + pell; 388 *sign_V_ptr = INDEX(pelu, thr) + INDEX(pelc, thr) + 389 INDEX(pell, thr); 390 391 sum1 = *(sign_V_ptr - 2) + *(sign_V_ptr - 1) + *sign_V_ptr; 392 /* the "if" statement below is the same as the one in 393 / the first loop */ 394 if (sum1 == 0 || sum1 == 9) 395 { 396 sum = (*(sum_V_ptr - 2) + (*(sum_V_ptr - 1) << 1) + 397 *sum_V_ptr + 8) >> 4; 398 399 Rec_Y_ptr--; 400 if ((int)(*Rec_Y_ptr - sum) > max_diff) 401 { 402 sum = *Rec_Y_ptr - max_diff; 403 } 404 else if ((int)(*Rec_Y_ptr - sum) < -max_diff) 405 { 406 sum = *Rec_Y_ptr + max_diff; 407 } 408 *Rec_Y_ptr++ = (uint8) sum; 409 } 410 Rec_Y_ptr++; 411 sum_V_ptr++; 412 sign_V_ptr++; 413 } 414 } 415 416 /*---------------------------------------------------------------------------- 417 ; Return nothing or data or data pointer 418 ----------------------------------------------------------------------------*/ 419 return; 420} 421#endif 422