1/* 2 * Copyright (C) 2011 The Android Open Source Project 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 express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16/** 17 ************************************************************************* 18 * @file M4AIR_API.c 19 * @brief Area of Interest Resizer API 20 ************************************************************************* 21 */ 22 23#define M4AIR_YUV420_FORMAT_SUPPORTED 24#define M4AIR_YUV420A_FORMAT_SUPPORTED 25 26/************************* COMPILATION CHECKS ***************************/ 27#ifndef M4AIR_YUV420_FORMAT_SUPPORTED 28#ifndef M4AIR_BGR565_FORMAT_SUPPORTED 29#ifndef M4AIR_RGB565_FORMAT_SUPPORTED 30#ifndef M4AIR_BGR888_FORMAT_SUPPORTED 31#ifndef M4AIR_RGB888_FORMAT_SUPPORTED 32#ifndef M4AIR_JPG_FORMAT_SUPPORTED 33 34#error "Please define at least one input format for the AIR component" 35 36#endif 37#endif 38#endif 39#endif 40#endif 41#endif 42 43/******************************* INCLUDES *******************************/ 44#include "M4OSA_Types.h" 45#include "M4OSA_Error.h" 46#include "M4OSA_CoreID.h" 47#include "M4OSA_Mutex.h" 48#include "M4OSA_Memory.h" 49#include "M4VIFI_FiltersAPI.h" 50#include "M4AIR_API.h" 51 52/************************ M4AIR INTERNAL TYPES DEFINITIONS ***********************/ 53 54/** 55 ****************************************************************************** 56 * enum M4AIR_States 57 * @brief The following enumeration defines the internal states of the AIR. 58 ****************************************************************************** 59 */ 60typedef enum 61{ 62 M4AIR_kCreated, /**< State after M4AIR_create has been called */ 63 M4AIR_kConfigured /**< State after M4AIR_configure has been called */ 64}M4AIR_States; 65 66 67/** 68 ****************************************************************************** 69 * struct M4AIR_InternalContext 70 * @brief The following structure is the internal context of the AIR. 71 ****************************************************************************** 72 */ 73typedef struct 74{ 75 M4AIR_States m_state; /**< Internal state */ 76 M4AIR_InputFormatType m_inputFormat; /**< Input format like YUV420Planar, 77 RGB565, JPG, etc ... */ 78 M4AIR_Params m_params; /**< Current input Parameter of the processing */ 79 M4OSA_UInt32 u32_x_inc[4]; /**< ratio between input and ouput width for YUV */ 80 M4OSA_UInt32 u32_y_inc[4]; /**< ratio between input and ouput height for YUV */ 81 M4OSA_UInt32 u32_x_accum_start[4]; /**< horizontal initial accumulator value */ 82 M4OSA_UInt32 u32_y_accum_start[4]; /**< Vertical initial accumulator value */ 83 M4OSA_UInt32 u32_x_accum[4]; /**< save of horizontal accumulator value */ 84 M4OSA_UInt32 u32_y_accum[4]; /**< save of vertical accumulator value */ 85 M4OSA_UInt8* pu8_data_in[4]; /**< Save of input plane pointers 86 in case of stripe mode */ 87 M4OSA_UInt32 m_procRows; /**< Number of processed rows, 88 used in stripe mode only */ 89 M4OSA_Bool m_bOnlyCopy; /**< Flag to know if we just perform a copy 90 or a bilinear interpolation */ 91 M4OSA_Bool m_bFlipX; /**< Depend on output orientation, used during 92 processing to revert processing order in X 93 coordinates */ 94 M4OSA_Bool m_bFlipY; /**< Depend on output orientation, used during 95 processing to revert processing order in Y 96 coordinates */ 97 M4OSA_Bool m_bRevertXY; /**< Depend on output orientation, used during 98 processing to revert X and Y processing order 99 (+-90� rotation) */ 100}M4AIR_InternalContext; 101 102/********************************* MACROS *******************************/ 103#define M4ERR_CHECK_NULL_RETURN_VALUE(retval, pointer)\ 104 if ((pointer) == M4OSA_NULL) return ((M4OSA_ERR)(retval)); 105 106 107/********************** M4AIR PUBLIC API IMPLEMENTATION ********************/ 108/** 109 ****************************************************************************** 110 * M4OSA_ERR M4AIR_create(M4OSA_Context* pContext,M4AIR_InputFormatType inputFormat) 111 * @brief This function initialize an instance of the AIR. 112 * @param pContext: (IN/OUT) Address of the context to create 113 * @param inputFormat: (IN) input format type. 114 * @return M4NO_ERROR: there is no error 115 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). Invalid formatType 116 * @return M4ERR_ALLOC: No more memory is available 117 ****************************************************************************** 118 */ 119M4OSA_ERR M4AIR_create(M4OSA_Context* pContext,M4AIR_InputFormatType inputFormat) 120{ 121 M4OSA_ERR err = M4NO_ERROR ; 122 M4AIR_InternalContext* pC = M4OSA_NULL ; 123 124 /* Check that the address on the context is not NULL */ 125 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 126 127 *pContext = M4OSA_NULL ; 128 129 /* Internal Context creation */ 130 pC = (M4AIR_InternalContext*)M4OSA_32bitAlignedMalloc(sizeof(M4AIR_InternalContext), 131 M4AIR,(M4OSA_Char *)"AIR internal context") ; 132 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, pC) ; 133 134 135 /* Check if the input format is supported */ 136 switch(inputFormat) 137 { 138#ifdef M4AIR_YUV420_FORMAT_SUPPORTED 139 case M4AIR_kYUV420P: 140 break ; 141#endif 142#ifdef M4AIR_YUV420A_FORMAT_SUPPORTED 143 case M4AIR_kYUV420AP: 144 break ; 145#endif 146 default: 147 err = M4ERR_AIR_FORMAT_NOT_SUPPORTED; 148 goto M4AIR_create_cleanup ; 149 } 150 151 /**< Save input format and update state */ 152 pC->m_inputFormat = inputFormat; 153 pC->m_state = M4AIR_kCreated; 154 155 /* Return the context to the caller */ 156 *pContext = pC ; 157 158 return M4NO_ERROR ; 159 160M4AIR_create_cleanup: 161 /* Error management : we destroy the context if needed */ 162 if(M4OSA_NULL != pC) 163 { 164 free(pC) ; 165 } 166 167 *pContext = M4OSA_NULL ; 168 169 return err ; 170} 171 172 173 174/** 175 ****************************************************************************** 176 * M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) 177 * @brief This function destroys an instance of the AIR component 178 * @param pContext: (IN) Context identifying the instance to destroy 179 * @return M4NO_ERROR: there is no error 180 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 181 * @return M4ERR_STATE: Internal state is incompatible with this function call. 182 ****************************************************************************** 183 */ 184M4OSA_ERR M4AIR_cleanUp(M4OSA_Context pContext) 185{ 186 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 187 188 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 189 190 /**< Check state */ 191 if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) 192 { 193 return M4ERR_STATE; 194 } 195 free(pC) ; 196 197 return M4NO_ERROR ; 198 199} 200 201 202/** 203 ****************************************************************************** 204 * M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) 205 * @brief This function will configure the AIR. 206 * @note It will set the input and output coordinates and sizes, 207 * and indicates if we will proceed in stripe or not. 208 * In case a M4AIR_get in stripe mode was on going, it will cancel this previous 209 * processing and reset the get process. 210 * @param pContext: (IN) Context identifying the instance 211 * @param pParams->m_bOutputStripe:(IN) Stripe mode. 212 * @param pParams->m_inputCoord: (IN) X,Y coordinates of the first valid pixel in input. 213 * @param pParams->m_inputSize: (IN) input ROI size. 214 * @param pParams->m_outputSize: (IN) output size. 215 * @return M4NO_ERROR: there is no error 216 * @return M4ERR_ALLOC: No more memory space to add a new effect. 217 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 218 * @return M4ERR_AIR_FORMAT_NOT_SUPPORTED: the requested input format is not supported. 219 ****************************************************************************** 220 */ 221M4OSA_ERR M4AIR_configure(M4OSA_Context pContext, M4AIR_Params* pParams) 222{ 223 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 224 M4OSA_UInt32 i,u32_width_in, u32_width_out, u32_height_in, u32_height_out; 225 M4OSA_UInt32 nb_planes; 226 227 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 228 229 if(M4AIR_kYUV420AP == pC->m_inputFormat) 230 { 231 nb_planes = 4; 232 } 233 else 234 { 235 nb_planes = 3; 236 } 237 238 /**< Check state */ 239 if((M4AIR_kCreated != pC->m_state)&&(M4AIR_kConfigured != pC->m_state)) 240 { 241 return M4ERR_STATE; 242 } 243 244 /** Save parameters */ 245 pC->m_params = *pParams; 246 247 /* Check for the input&output width and height are even */ 248 if( ((pC->m_params.m_inputSize.m_height)&0x1) || 249 ((pC->m_params.m_inputSize.m_height)&0x1)) 250 { 251 return M4ERR_AIR_ILLEGAL_FRAME_SIZE; 252 } 253 254 if( ((pC->m_params.m_inputSize.m_width)&0x1) || 255 ((pC->m_params.m_inputSize.m_width)&0x1)) 256 { 257 return M4ERR_AIR_ILLEGAL_FRAME_SIZE; 258 } 259 if(((pC->m_params.m_inputSize.m_width) == (pC->m_params.m_outputSize.m_width)) 260 &&((pC->m_params.m_inputSize.m_height) == (pC->m_params.m_outputSize.m_height))) 261 { 262 /**< No resize in this case, we will just copy input in output */ 263 pC->m_bOnlyCopy = M4OSA_TRUE; 264 } 265 else 266 { 267 pC->m_bOnlyCopy = M4OSA_FALSE; 268 269 /**< Initialize internal variables used for resize filter */ 270 for(i=0;i<nb_planes;i++) 271 { 272 273 u32_width_in = ((i==0)||(i==3))?pC->m_params.m_inputSize.m_width:\ 274 (pC->m_params.m_inputSize.m_width+1)>>1; 275 u32_height_in = ((i==0)||(i==3))?pC->m_params.m_inputSize.m_height:\ 276 (pC->m_params.m_inputSize.m_height+1)>>1; 277 u32_width_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_width:\ 278 (pC->m_params.m_outputSize.m_width+1)>>1; 279 u32_height_out = ((i==0)||(i==3))?pC->m_params.m_outputSize.m_height:\ 280 (pC->m_params.m_outputSize.m_height+1)>>1; 281 282 /* Compute horizontal ratio between src and destination width.*/ 283 if (u32_width_out >= u32_width_in) 284 { 285 pC->u32_x_inc[i] = ((u32_width_in-1) * 0x10000) / (u32_width_out-1); 286 } 287 else 288 { 289 pC->u32_x_inc[i] = (u32_width_in * 0x10000) / (u32_width_out); 290 } 291 292 /* Compute vertical ratio between src and destination height.*/ 293 if (u32_height_out >= u32_height_in) 294 { 295 pC->u32_y_inc[i] = ((u32_height_in - 1) * 0x10000) / (u32_height_out-1); 296 } 297 else 298 { 299 pC->u32_y_inc[i] = (u32_height_in * 0x10000) / (u32_height_out); 300 } 301 302 /* 303 Calculate initial accumulator value : u32_y_accum_start. 304 u32_y_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 305 */ 306 if (pC->u32_y_inc[i] >= 0x10000) 307 { 308 /* 309 Keep the fractionnal part, assimung that integer part is coded 310 on the 16 high bits and the fractionnal on the 15 low bits 311 */ 312 pC->u32_y_accum_start[i] = pC->u32_y_inc[i] & 0xffff; 313 314 if (!pC->u32_y_accum_start[i]) 315 { 316 pC->u32_y_accum_start[i] = 0x10000; 317 } 318 319 pC->u32_y_accum_start[i] >>= 1; 320 } 321 else 322 { 323 pC->u32_y_accum_start[i] = 0; 324 } 325 /**< Take into account that Y coordinate can be odd 326 in this case we have to put a 0.5 offset 327 for U and V plane as there a 2 times sub-sampled vs Y*/ 328 if((pC->m_params.m_inputCoord.m_y&0x1)&&((i==1)||(i==2))) 329 { 330 pC->u32_y_accum_start[i] += 0x8000; 331 } 332 333 /* 334 Calculate initial accumulator value : u32_x_accum_start. 335 u32_x_accum_start is coded on 15 bits, and represents a value between 336 0 and 0.5 337 */ 338 339 if (pC->u32_x_inc[i] >= 0x10000) 340 { 341 pC->u32_x_accum_start[i] = pC->u32_x_inc[i] & 0xffff; 342 343 if (!pC->u32_x_accum_start[i]) 344 { 345 pC->u32_x_accum_start[i] = 0x10000; 346 } 347 348 pC->u32_x_accum_start[i] >>= 1; 349 } 350 else 351 { 352 pC->u32_x_accum_start[i] = 0; 353 } 354 /**< Take into account that X coordinate can be odd 355 in this case we have to put a 0.5 offset 356 for U and V plane as there a 2 times sub-sampled vs Y*/ 357 if((pC->m_params.m_inputCoord.m_x&0x1)&&((i==1)||(i==2))) 358 { 359 pC->u32_x_accum_start[i] += 0x8000; 360 } 361 } 362 } 363 364 /**< Reset variable used for stripe mode */ 365 pC->m_procRows = 0; 366 367 /**< Initialize var for X/Y processing order according to orientation */ 368 pC->m_bFlipX = M4OSA_FALSE; 369 pC->m_bFlipY = M4OSA_FALSE; 370 pC->m_bRevertXY = M4OSA_FALSE; 371 switch(pParams->m_outputOrientation) 372 { 373 case M4COMMON_kOrientationTopLeft: 374 break; 375 case M4COMMON_kOrientationTopRight: 376 pC->m_bFlipX = M4OSA_TRUE; 377 break; 378 case M4COMMON_kOrientationBottomRight: 379 pC->m_bFlipX = M4OSA_TRUE; 380 pC->m_bFlipY = M4OSA_TRUE; 381 break; 382 case M4COMMON_kOrientationBottomLeft: 383 pC->m_bFlipY = M4OSA_TRUE; 384 break; 385 case M4COMMON_kOrientationLeftTop: 386 pC->m_bRevertXY = M4OSA_TRUE; 387 break; 388 case M4COMMON_kOrientationRightTop: 389 pC->m_bRevertXY = M4OSA_TRUE; 390 pC->m_bFlipY = M4OSA_TRUE; 391 break; 392 case M4COMMON_kOrientationRightBottom: 393 pC->m_bRevertXY = M4OSA_TRUE; 394 pC->m_bFlipX = M4OSA_TRUE; 395 pC->m_bFlipY = M4OSA_TRUE; 396 break; 397 case M4COMMON_kOrientationLeftBottom: 398 pC->m_bRevertXY = M4OSA_TRUE; 399 pC->m_bFlipX = M4OSA_TRUE; 400 break; 401 default: 402 return M4ERR_PARAMETER; 403 } 404 /**< Update state */ 405 pC->m_state = M4AIR_kConfigured; 406 407 return M4NO_ERROR ; 408} 409 410 411/** 412 ****************************************************************************** 413 * M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) 414 * @brief This function will provide the requested resized area of interest according to 415 * settings provided in M4AIR_configure. 416 * @note In case the input format type is JPEG, input plane(s) 417 * in pIn is not used. In normal mode, dimension specified in output plane(s) structure 418 * must be the same than the one specified in M4AIR_configure. In stripe mode, only the 419 * width will be the same, height will be taken as the stripe height (typically 16). 420 * In normal mode, this function is call once to get the full output picture. 421 * In stripe mode, it is called for each stripe till the whole picture has been 422 * retrieved,and the position of the output stripe in the output picture 423 * is internally incremented at each step. 424 * Any call to M4AIR_configure during stripe process will reset this one to the 425 * beginning of the output picture. 426 * @param pContext: (IN) Context identifying the instance 427 * @param pIn: (IN) Plane structure containing input Plane(s). 428 * @param pOut: (IN/OUT) Plane structure containing output Plane(s). 429 * @return M4NO_ERROR: there is no error 430 * @return M4ERR_ALLOC: No more memory space to add a new effect. 431 * @return M4ERR_PARAMETER: pContext is M4OSA_NULL (debug only). 432 ****************************************************************************** 433 */ 434M4OSA_ERR M4AIR_get(M4OSA_Context pContext, M4VIFI_ImagePlane* pIn, M4VIFI_ImagePlane* pOut) 435{ 436 M4AIR_InternalContext* pC = (M4AIR_InternalContext*)pContext ; 437 M4OSA_UInt32 i,j,k,u32_x_frac,u32_y_frac,u32_x_accum,u32_y_accum,u32_shift; 438 M4OSA_UInt8 *pu8_data_in, *pu8_data_in_org, *pu8_data_in_tmp, *pu8_data_out; 439 M4OSA_UInt8 *pu8_src_top; 440 M4OSA_UInt8 *pu8_src_bottom; 441 M4OSA_UInt32 u32_temp_value; 442 M4OSA_Int32 i32_tmp_offset; 443 M4OSA_UInt32 nb_planes; 444 445 446 447 M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext) ; 448 449 /**< Check state */ 450 if(M4AIR_kConfigured != pC->m_state) 451 { 452 return M4ERR_STATE; 453 } 454 455 if(M4AIR_kYUV420AP == pC->m_inputFormat) 456 { 457 nb_planes = 4; 458 } 459 else 460 { 461 nb_planes = 3; 462 } 463 464 /**< Loop on each Plane */ 465 for(i=0;i<nb_planes;i++) 466 { 467 468 /* Set the working pointers at the beginning of the input/output data field */ 469 470 u32_shift = ((i==0)||(i==3))?0:1; /**< Depend on Luma or Chroma */ 471 472 if((M4OSA_FALSE == pC->m_params.m_bOutputStripe)\ 473 ||((M4OSA_TRUE == pC->m_params.m_bOutputStripe)&&(0 == pC->m_procRows))) 474 { 475 /**< For input, take care about ROI */ 476 pu8_data_in = pIn[i].pac_data + pIn[i].u_topleft \ 477 + (pC->m_params.m_inputCoord.m_x>>u32_shift) 478 + (pC->m_params.m_inputCoord.m_y >> u32_shift) * pIn[i].u_stride; 479 480 /** Go at end of line/column in case X/Y scanning is flipped */ 481 if(M4OSA_TRUE == pC->m_bFlipX) 482 { 483 pu8_data_in += ((pC->m_params.m_inputSize.m_width)>>u32_shift) -1 ; 484 } 485 if(M4OSA_TRUE == pC->m_bFlipY) 486 { 487 pu8_data_in += ((pC->m_params.m_inputSize.m_height>>u32_shift) -1)\ 488 * pIn[i].u_stride; 489 } 490 491 /**< Initialize accumulators in case we are using it (bilinear interpolation) */ 492 if( M4OSA_FALSE == pC->m_bOnlyCopy) 493 { 494 pC->u32_x_accum[i] = pC->u32_x_accum_start[i]; 495 pC->u32_y_accum[i] = pC->u32_y_accum_start[i]; 496 } 497 498 } 499 else 500 { 501 /**< In case of stripe mode for other than first stripe, we need to recover input 502 pointer from internal context */ 503 pu8_data_in = pC->pu8_data_in[i]; 504 } 505 506 /**< In every mode, output data are at the beginning of the output plane */ 507 pu8_data_out = pOut[i].pac_data + pOut[i].u_topleft; 508 509 /**< Initialize input offset applied after each pixel */ 510 if(M4OSA_FALSE == pC->m_bFlipY) 511 { 512 i32_tmp_offset = pIn[i].u_stride; 513 } 514 else 515 { 516 i32_tmp_offset = -pIn[i].u_stride; 517 } 518 519 /**< In this case, no bilinear interpolation is needed as input and output dimensions 520 are the same */ 521 if( M4OSA_TRUE == pC->m_bOnlyCopy) 522 { 523 /**< No +-90� rotation */ 524 if(M4OSA_FALSE == pC->m_bRevertXY) 525 { 526 /**< No flip on X abscissa */ 527 if(M4OSA_FALSE == pC->m_bFlipX) 528 { 529 /**< Loop on each row */ 530 for(j=0;j<pOut[i].u_height;j++) 531 { 532 /**< Copy one whole line */ 533 memcpy((void *)pu8_data_out, (void *)pu8_data_in, 534 pOut[i].u_width); 535 536 /**< Update pointers */ 537 pu8_data_out += pOut[i].u_stride; 538 if(M4OSA_FALSE == pC->m_bFlipY) 539 { 540 pu8_data_in += pIn[i].u_stride; 541 } 542 else 543 { 544 pu8_data_in -= pIn[i].u_stride; 545 } 546 } 547 } 548 else 549 { 550 /**< Loop on each row */ 551 for(j=0;j<pOut[i].u_height;j++) 552 { 553 /**< Loop on each pixel of 1 row */ 554 for(k=0;k<pOut[i].u_width;k++) 555 { 556 *pu8_data_out++ = *pu8_data_in--; 557 } 558 559 /**< Update pointers */ 560 pu8_data_out += (pOut[i].u_stride - pOut[i].u_width); 561 562 pu8_data_in += pOut[i].u_width + i32_tmp_offset; 563 564 } 565 } 566 } 567 /**< Here we have a +-90� rotation */ 568 else 569 { 570 571 /**< Loop on each row */ 572 for(j=0;j<pOut[i].u_height;j++) 573 { 574 pu8_data_in_tmp = pu8_data_in; 575 576 /**< Loop on each pixel of 1 row */ 577 for(k=0;k<pOut[i].u_width;k++) 578 { 579 *pu8_data_out++ = *pu8_data_in_tmp; 580 581 /**< Update input pointer in order to go to next/past line */ 582 pu8_data_in_tmp += i32_tmp_offset; 583 } 584 585 /**< Update pointers */ 586 pu8_data_out += (pOut[i].u_stride - pOut[i].u_width); 587 if(M4OSA_FALSE == pC->m_bFlipX) 588 { 589 pu8_data_in ++; 590 } 591 else 592 { 593 pu8_data_in --; 594 } 595 } 596 } 597 } 598 /**< Bilinear interpolation */ 599 else 600 { 601 602 if(3 != i) /**< other than alpha plane */ 603 { 604 /**No +-90� rotation */ 605 if(M4OSA_FALSE == pC->m_bRevertXY) 606 { 607 608 /**< Loop on each row */ 609 for(j=0;j<pOut[i].u_height;j++) 610 { 611 /* Vertical weight factor */ 612 u32_y_frac = (pC->u32_y_accum[i]>>12)&15; 613 614 /* Reinit horizontal weight factor */ 615 u32_x_accum = pC->u32_x_accum_start[i]; 616 617 618 619 if(M4OSA_TRUE == pC->m_bFlipX) 620 { 621 622 /**< Loop on each output pixel in a row */ 623 for(k=0;k<pOut[i].u_width;k++) 624 { 625 626 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal 627 weight factor */ 628 629 pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; 630 631 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 632 633 /* Weighted combination */ 634 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 635 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 636 (pu8_src_bottom[1]*(16-u32_x_frac) + 637 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 638 639 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 640 641 /* Update horizontal accumulator */ 642 u32_x_accum += pC->u32_x_inc[i]; 643 } 644 } 645 646 else 647 { 648 /**< Loop on each output pixel in a row */ 649 for(k=0;k<pOut[i].u_width;k++) 650 { 651 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal 652 weight factor */ 653 654 pu8_src_top = pu8_data_in + (u32_x_accum >> 16); 655 656 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 657 658 /* Weighted combination */ 659 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 660 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 661 (pu8_src_bottom[0]*(16-u32_x_frac) + 662 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 663 664 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 665 666 /* Update horizontal accumulator */ 667 u32_x_accum += pC->u32_x_inc[i]; 668 } 669 670 } 671 672 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 673 674 /* Update vertical accumulator */ 675 pC->u32_y_accum[i] += pC->u32_y_inc[i]; 676 if (pC->u32_y_accum[i]>>16) 677 { 678 pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; 679 pC->u32_y_accum[i] &= 0xffff; 680 } 681 } 682 } 683 /** +-90� rotation */ 684 else 685 { 686 pu8_data_in_org = pu8_data_in; 687 688 /**< Loop on each output row */ 689 for(j=0;j<pOut[i].u_height;j++) 690 { 691 /* horizontal weight factor */ 692 u32_x_frac = (pC->u32_x_accum[i]>>12)&15; 693 694 /* Reinit accumulator */ 695 u32_y_accum = pC->u32_y_accum_start[i]; 696 697 if(M4OSA_TRUE == pC->m_bFlipX) 698 { 699 700 /**< Loop on each output pixel in a row */ 701 for(k=0;k<pOut[i].u_width;k++) 702 { 703 704 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 705 706 707 pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; 708 709 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 710 711 /* Weighted combination */ 712 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 713 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 714 (pu8_src_bottom[1]*(16-u32_x_frac) + 715 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 716 717 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 718 719 /* Update vertical accumulator */ 720 u32_y_accum += pC->u32_y_inc[i]; 721 if (u32_y_accum>>16) 722 { 723 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 724 u32_y_accum &= 0xffff; 725 } 726 727 } 728 } 729 else 730 { 731 /**< Loop on each output pixel in a row */ 732 for(k=0;k<pOut[i].u_width;k++) 733 { 734 735 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 736 737 pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); 738 739 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 740 741 /* Weighted combination */ 742 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 743 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 744 (pu8_src_bottom[0]*(16-u32_x_frac) + 745 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 746 747 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 748 749 /* Update vertical accumulator */ 750 u32_y_accum += pC->u32_y_inc[i]; 751 if (u32_y_accum>>16) 752 { 753 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 754 u32_y_accum &= 0xffff; 755 } 756 } 757 } 758 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 759 760 /* Update horizontal accumulator */ 761 pC->u32_x_accum[i] += pC->u32_x_inc[i]; 762 763 pu8_data_in = pu8_data_in_org; 764 } 765 766 } 767 }/** 3 != i */ 768 else 769 { 770 /**No +-90� rotation */ 771 if(M4OSA_FALSE == pC->m_bRevertXY) 772 { 773 774 /**< Loop on each row */ 775 for(j=0;j<pOut[i].u_height;j++) 776 { 777 /* Vertical weight factor */ 778 u32_y_frac = (pC->u32_y_accum[i]>>12)&15; 779 780 /* Reinit horizontal weight factor */ 781 u32_x_accum = pC->u32_x_accum_start[i]; 782 783 784 785 if(M4OSA_TRUE == pC->m_bFlipX) 786 { 787 788 /**< Loop on each output pixel in a row */ 789 for(k=0;k<pOut[i].u_width;k++) 790 { 791 792 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal 793 weight factor */ 794 795 pu8_src_top = (pu8_data_in - (u32_x_accum >> 16)) -1 ; 796 797 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 798 799 /* Weighted combination */ 800 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 801 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 802 (pu8_src_bottom[1]*(16-u32_x_frac) + 803 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 804 805 u32_temp_value= (u32_temp_value >> 7)*0xff; 806 807 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 808 809 /* Update horizontal accumulator */ 810 u32_x_accum += pC->u32_x_inc[i]; 811 } 812 } 813 814 else 815 { 816 /**< Loop on each output pixel in a row */ 817 for(k=0;k<pOut[i].u_width;k++) 818 { 819 u32_x_frac = (u32_x_accum >> 12)&15; /* Fraction of Horizontal 820 weight factor */ 821 822 pu8_src_top = pu8_data_in + (u32_x_accum >> 16); 823 824 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 825 826 /* Weighted combination */ 827 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 828 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 829 (pu8_src_bottom[0]*(16-u32_x_frac) + 830 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 831 832 u32_temp_value= (u32_temp_value >> 7)*0xff; 833 834 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 835 836 /* Update horizontal accumulator */ 837 u32_x_accum += pC->u32_x_inc[i]; 838 } 839 840 } 841 842 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 843 844 /* Update vertical accumulator */ 845 pC->u32_y_accum[i] += pC->u32_y_inc[i]; 846 if (pC->u32_y_accum[i]>>16) 847 { 848 pu8_data_in = pu8_data_in + (pC->u32_y_accum[i] >> 16) * i32_tmp_offset; 849 pC->u32_y_accum[i] &= 0xffff; 850 } 851 } 852 853 } /**< M4OSA_FALSE == pC->m_bRevertXY */ 854 /** +-90� rotation */ 855 else 856 { 857 pu8_data_in_org = pu8_data_in; 858 859 /**< Loop on each output row */ 860 for(j=0;j<pOut[i].u_height;j++) 861 { 862 /* horizontal weight factor */ 863 u32_x_frac = (pC->u32_x_accum[i]>>12)&15; 864 865 /* Reinit accumulator */ 866 u32_y_accum = pC->u32_y_accum_start[i]; 867 868 if(M4OSA_TRUE == pC->m_bFlipX) 869 { 870 871 /**< Loop on each output pixel in a row */ 872 for(k=0;k<pOut[i].u_width;k++) 873 { 874 875 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 876 877 878 pu8_src_top = (pu8_data_in - (pC->u32_x_accum[i] >> 16)) - 1; 879 880 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 881 882 /* Weighted combination */ 883 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[1]*(16-u32_x_frac) + 884 pu8_src_top[0]*u32_x_frac)*(16-u32_y_frac) + 885 (pu8_src_bottom[1]*(16-u32_x_frac) + 886 pu8_src_bottom[0]*u32_x_frac)*u32_y_frac )>>8); 887 888 u32_temp_value= (u32_temp_value >> 7)*0xff; 889 890 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 891 892 /* Update vertical accumulator */ 893 u32_y_accum += pC->u32_y_inc[i]; 894 if (u32_y_accum>>16) 895 { 896 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 897 u32_y_accum &= 0xffff; 898 } 899 900 } 901 } 902 else 903 { 904 /**< Loop on each output pixel in a row */ 905 for(k=0;k<pOut[i].u_width;k++) 906 { 907 908 u32_y_frac = (u32_y_accum >> 12)&15; /* Vertical weight factor */ 909 910 pu8_src_top = pu8_data_in + (pC->u32_x_accum[i] >> 16); 911 912 pu8_src_bottom = pu8_src_top + i32_tmp_offset; 913 914 /* Weighted combination */ 915 u32_temp_value = (M4VIFI_UInt8)(((pu8_src_top[0]*(16-u32_x_frac) + 916 pu8_src_top[1]*u32_x_frac)*(16-u32_y_frac) + 917 (pu8_src_bottom[0]*(16-u32_x_frac) + 918 pu8_src_bottom[1]*u32_x_frac)*u32_y_frac )>>8); 919 920 u32_temp_value= (u32_temp_value >> 7)*0xff; 921 922 *pu8_data_out++ = (M4VIFI_UInt8)u32_temp_value; 923 924 /* Update vertical accumulator */ 925 u32_y_accum += pC->u32_y_inc[i]; 926 if (u32_y_accum>>16) 927 { 928 pu8_data_in = pu8_data_in + (u32_y_accum >> 16) * i32_tmp_offset; 929 u32_y_accum &= 0xffff; 930 } 931 } 932 } 933 pu8_data_out += pOut[i].u_stride - pOut[i].u_width; 934 935 /* Update horizontal accumulator */ 936 pC->u32_x_accum[i] += pC->u32_x_inc[i]; 937 938 pu8_data_in = pu8_data_in_org; 939 940 } 941 } /**< M4OSA_TRUE == pC->m_bRevertXY */ 942 }/** 3 == i */ 943 } 944 /**< In case of stripe mode, save current input pointer */ 945 if(M4OSA_TRUE == pC->m_params.m_bOutputStripe) 946 { 947 pC->pu8_data_in[i] = pu8_data_in; 948 } 949 } 950 951 /**< Update number of processed rows, reset it if we have finished 952 with the whole processing */ 953 pC->m_procRows += pOut[0].u_height; 954 if(M4OSA_FALSE == pC->m_bRevertXY) 955 { 956 if(pC->m_params.m_outputSize.m_height <= pC->m_procRows) pC->m_procRows = 0; 957 } 958 else 959 { 960 if(pC->m_params.m_outputSize.m_width <= pC->m_procRows) pC->m_procRows = 0; 961 } 962 963 return M4NO_ERROR ; 964 965} 966 967 968 969