/* * Copyright (C) 2011 The Android Open Source Project * * 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. */ /** ****************************************************************************** * @file M4VIFI_ResizeYUV420toBGR565.c * @brief Contain video library function * @note This file has a Combo filter function * -# Resizes YUV420 and converts to RGR565 with rotation ****************************************************************************** */ /* Prototypes of functions, and type definitions */ #include "M4VIFI_FiltersAPI.h" /* Macro definitions */ #include "M4VIFI_Defines.h" /* Clip table declaration */ #include "M4VIFI_Clip.h" /** ********************************************************************************************* * M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toBGR565(void *pContext, M4VIFI_ImagePlane *pPlaneIn, * M4VIFI_ImagePlane *pPlaneOut) * @brief Resize YUV420 plane and converts to BGR565 with +90 rotation. * @note Basic sturture of the function * Loop on each row (step 2) * Loop on each column (step 2) * Get four Y samples and 1 u & V sample * Resize the Y with corresponing U and V samples * Compute the four corresponding R G B values * Place the R G B in the ouput plane in rotated fashion * end loop column * end loop row * For resizing bilinear interpolation linearly interpolates along * each row, and then uses that result in a linear interpolation down each column. * Each estimated pixel in the output image is a weighted * combination of its four neighbours. The ratio of compression * or dilatation is estimated using input and output sizes. * @param pPlaneIn: (IN) Pointer to YUV plane buffer * @param pContext: (IN) Context Pointer * @param pPlaneOut: (OUT) Pointer to BGR565 Plane * @return M4VIFI_OK: there is no error * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: YUV Plane height is ODD * @return M4VIFI_ILLEGAL_FRAME_WIDTH: YUV Plane width is ODD ********************************************************************************************* */ M4VIFI_UInt8 M4VIFI_ResizeBilinearYUV420toBGR565(void* pContext, M4VIFI_ImagePlane *pPlaneIn, M4VIFI_ImagePlane *pPlaneOut) { M4VIFI_UInt8 *pu8_data_in[PLANES], *pu8_data_in1[PLANES],*pu8_data_out; M4VIFI_UInt32 *pu32_rgb_data_current, *pu32_rgb_data_next, *pu32_rgb_data_start; M4VIFI_UInt32 u32_width_in[PLANES], u32_width_out, u32_height_in[PLANES], u32_height_out; M4VIFI_UInt32 u32_stride_in[PLANES]; M4VIFI_UInt32 u32_stride_out, u32_stride2_out, u32_width2_RGB, u32_height2_RGB; M4VIFI_UInt32 u32_x_inc[PLANES], u32_y_inc[PLANES]; M4VIFI_UInt32 u32_x_accum_Y, u32_x_accum_U, u32_x_accum_start; M4VIFI_UInt32 u32_y_accum_Y, u32_y_accum_U; M4VIFI_UInt32 u32_x_frac_Y, u32_x_frac_U, u32_y_frac_Y,u32_y_frac_U; M4VIFI_Int32 U_32, V_32, Y_32, Yval_32; M4VIFI_UInt8 u8_Red, u8_Green, u8_Blue; M4VIFI_UInt32 u32_row, u32_col; M4VIFI_UInt32 u32_plane; M4VIFI_UInt32 u32_rgb_temp1, u32_rgb_temp2; M4VIFI_UInt32 u32_rgb_temp3,u32_rgb_temp4; M4VIFI_UInt32 u32_check_size; M4VIFI_UInt8 *pu8_src_top_Y,*pu8_src_top_U,*pu8_src_top_V ; M4VIFI_UInt8 *pu8_src_bottom_Y, *pu8_src_bottom_U, *pu8_src_bottom_V; /* Check for the YUV width and height are even */ u32_check_size = IS_EVEN(pPlaneIn[0].u_height); if( u32_check_size == FALSE ) { return M4VIFI_ILLEGAL_FRAME_HEIGHT; } u32_check_size = IS_EVEN(pPlaneIn[0].u_width); if (u32_check_size == FALSE ) { return M4VIFI_ILLEGAL_FRAME_WIDTH; } /* Make the ouput width and height as even */ pPlaneOut->u_height = pPlaneOut->u_height & 0xFFFFFFFE; pPlaneOut->u_width = pPlaneOut->u_width & 0xFFFFFFFE; pPlaneOut->u_stride = pPlaneOut->u_stride & 0xFFFFFFFC; /* Assignment of output pointer */ pu8_data_out = pPlaneOut->pac_data + pPlaneOut->u_topleft; /* Assignment of output width(rotated) */ u32_width_out = pPlaneOut->u_width; /* Assignment of output height(rotated) */ u32_height_out = pPlaneOut->u_height; u32_width2_RGB = pPlaneOut->u_width >> 1; u32_height2_RGB = pPlaneOut->u_height >> 1; u32_stride_out = pPlaneOut->u_stride >> 1; u32_stride2_out = pPlaneOut->u_stride >> 2; for(u32_plane = 0; u32_plane < PLANES; u32_plane++) { /* Set the working pointers at the beginning of the input/output data field */ pu8_data_in[u32_plane] = pPlaneIn[u32_plane].pac_data + pPlaneIn[u32_plane].u_topleft; /* Get the memory jump corresponding to a row jump */ u32_stride_in[u32_plane] = pPlaneIn[u32_plane].u_stride; /* Set the bounds of the active image */ u32_width_in[u32_plane] = pPlaneIn[u32_plane].u_width; u32_height_in[u32_plane] = pPlaneIn[u32_plane].u_height; } /* Compute horizontal ratio between src and destination width for Y Plane. */ if (u32_width_out >= u32_width_in[YPlane]) { u32_x_inc[YPlane] = ((u32_width_in[YPlane]-1) * MAX_SHORT) / (u32_width_out-1); } else { u32_x_inc[YPlane] = (u32_width_in[YPlane] * MAX_SHORT) / (u32_width_out); } /* Compute vertical ratio between src and destination height for Y Plane.*/ if (u32_height_out >= u32_height_in[YPlane]) { u32_y_inc[YPlane] = ((u32_height_in[YPlane]-1) * MAX_SHORT) / (u32_height_out-1); } else { u32_y_inc[YPlane] = (u32_height_in[YPlane] * MAX_SHORT) / (u32_height_out); } /* Compute horizontal ratio between src and destination width for U and V Planes. */ if (u32_width2_RGB >= u32_width_in[UPlane]) { u32_x_inc[UPlane] = ((u32_width_in[UPlane]-1) * MAX_SHORT) / (u32_width2_RGB-1); } else { u32_x_inc[UPlane] = (u32_width_in[UPlane] * MAX_SHORT) / (u32_width2_RGB); } /* Compute vertical ratio between src and destination height for U and V Planes. */ if (u32_height2_RGB >= u32_height_in[UPlane]) { u32_y_inc[UPlane] = ((u32_height_in[UPlane]-1) * MAX_SHORT) / (u32_height2_RGB-1); } else { u32_y_inc[UPlane] = (u32_height_in[UPlane] * MAX_SHORT) / (u32_height2_RGB); } u32_y_inc[VPlane] = u32_y_inc[UPlane]; u32_x_inc[VPlane] = u32_x_inc[UPlane]; /* Calculate initial accumulator value : u32_y_accum_start. u32_y_accum_start is coded on 15 bits,and represents a value between 0 and 0.5 */ if (u32_y_inc[YPlane] > MAX_SHORT) { /* Keep the fractionnal part, assimung that integer part is coded on the 16 high bits, and the fractionnal on the 15 low bits */ u32_y_accum_Y = u32_y_inc[YPlane] & 0xffff; u32_y_accum_U = u32_y_inc[UPlane] & 0xffff; if (!u32_y_accum_Y) { u32_y_accum_Y = MAX_SHORT; u32_y_accum_U = MAX_SHORT; } u32_y_accum_Y >>= 1; u32_y_accum_U >>= 1; } else { u32_y_accum_Y = 0; u32_y_accum_U = 0; } /* Calculate initial accumulator value : u32_x_accum_start. u32_x_accum_start is coded on 15 bits, and represents a value between 0 and 0.5 */ if (u32_x_inc[YPlane] > MAX_SHORT) { u32_x_accum_start = u32_x_inc[YPlane] & 0xffff; if (!u32_x_accum_start) { u32_x_accum_start = MAX_SHORT; } u32_x_accum_start >>= 1; } else { u32_x_accum_start = 0; } pu32_rgb_data_start = (M4VIFI_UInt32*)pu8_data_out; /* Bilinear interpolation linearly interpolates along each row, and then uses that result in a linear interpolation donw each column. Each estimated pixel in the output image is a weighted combination of its four neighbours according to the formula : F(p',q')=f(p,q)R(-a)R(b)+f(p,q-1)R(-a)R(b-1)+f(p+1,q)R(1-a)R(b)+f(p+&,q+1)R(1-a)R(b-1) with R(x) = / x+1 -1 =< x =< 0 \ 1-x 0 =< x =< 1 and a (resp. b) weighting coefficient is the distance from the nearest neighbor in the p (resp. q) direction */ for (u32_row = u32_height_out; u32_row != 0; u32_row -= 2) { u32_x_accum_Y = u32_x_accum_start; u32_x_accum_U = u32_x_accum_start; /* Vertical weight factor */ u32_y_frac_Y = (u32_y_accum_Y >> 12) & 15; u32_y_frac_U = (u32_y_accum_U >> 12) & 15; /* RGB current line position pointer */ pu32_rgb_data_current = pu32_rgb_data_start ; /* RGB next line position pointer */ pu32_rgb_data_next = pu32_rgb_data_current + (u32_stride2_out); /* Y Plane next row pointer */ pu8_data_in1[YPlane] = pu8_data_in[YPlane]; u32_rgb_temp3 = u32_y_accum_Y + (u32_y_inc[YPlane]); if (u32_rgb_temp3 >> 16) { pu8_data_in1[YPlane] = pu8_data_in[YPlane] + (u32_rgb_temp3 >> 16) * (u32_stride_in[YPlane]); u32_rgb_temp3 &= 0xffff; } u32_rgb_temp4 = (u32_rgb_temp3 >> 12) & 15; for (u32_col = u32_width_out; u32_col != 0; u32_col -= 2) { /* Input Y plane elements */ pu8_src_top_Y = pu8_data_in[YPlane] + (u32_x_accum_Y >> 16); pu8_src_bottom_Y = pu8_src_top_Y + u32_stride_in[YPlane]; /* Input U Plane elements */ pu8_src_top_U = pu8_data_in[UPlane] + (u32_x_accum_U >> 16); pu8_src_bottom_U = pu8_src_top_U + u32_stride_in[UPlane]; pu8_src_top_V = pu8_data_in[VPlane] + (u32_x_accum_U >> 16); pu8_src_bottom_V = pu8_src_top_V + u32_stride_in[VPlane]; /* Horizontal weight factor for Y plane */ u32_x_frac_Y = (u32_x_accum_Y >> 12)&15; /* Horizontal weight factor for U and V planes */ u32_x_frac_U = (u32_x_accum_U >> 12)&15; /* Weighted combination */ U_32 = (((pu8_src_top_U[0]*(16-u32_x_frac_U) + pu8_src_top_U[1]*u32_x_frac_U) *(16-u32_y_frac_U) + (pu8_src_bottom_U[0]*(16-u32_x_frac_U) + pu8_src_bottom_U[1]*u32_x_frac_U)*u32_y_frac_U ) >> 8); V_32 = (((pu8_src_top_V[0]*(16-u32_x_frac_U) + pu8_src_top_V[1]*u32_x_frac_U) *(16-u32_y_frac_U)+ (pu8_src_bottom_V[0]*(16-u32_x_frac_U) + pu8_src_bottom_V[1]*u32_x_frac_U)*u32_y_frac_U ) >> 8); Y_32 = (((pu8_src_top_Y[0]*(16-u32_x_frac_Y) + pu8_src_top_Y[1]*u32_x_frac_Y) *(16-u32_y_frac_Y) + (pu8_src_bottom_Y[0]*(16-u32_x_frac_Y) + pu8_src_bottom_Y[1]*u32_x_frac_Y)*u32_y_frac_Y ) >> 8); u32_x_accum_U += (u32_x_inc[UPlane]); /* YUV to RGB */ #ifdef __RGB_V1__ Yval_32 = Y_32*37; #else /* __RGB_V1__v */ Yval_32 = Y_32*0x2568; #endif /* __RGB_V1__v */ DEMATRIX(u8_Red,u8_Green,u8_Blue,Yval_32,U_32,V_32); /* Pack 8 bit R,G,B to RGB565 */ #ifdef LITTLE_ENDIAN u32_rgb_temp1 = PACK_BGR565(0,u8_Red,u8_Green,u8_Blue); #else /* LITTLE_ENDIAN */ u32_rgb_temp1 = PACK_BGR565(16,u8_Red,u8_Green,u8_Blue); #endif /* LITTLE_ENDIAN */ pu8_src_top_Y = pu8_data_in1[YPlane]+(u32_x_accum_Y >> 16); pu8_src_bottom_Y = pu8_src_top_Y + u32_stride_in[YPlane]; /* Weighted combination */ Y_32 = (((pu8_src_top_Y[0]*(16-u32_x_frac_Y) + pu8_src_top_Y[1]*u32_x_frac_Y) *(16-u32_rgb_temp4) + (pu8_src_bottom_Y[0]*(16-u32_x_frac_Y) + pu8_src_bottom_Y[1]*u32_x_frac_Y)*u32_rgb_temp4 ) >> 8); u32_x_accum_Y += u32_x_inc[YPlane]; /* Horizontal weight factor */ u32_x_frac_Y = (u32_x_accum_Y >> 12)&15; /* YUV to RGB */ #ifdef __RGB_V1__ Yval_32 = Y_32*37; #else /* __RGB_V1__v */ Yval_32 = Y_32*0x2568; #endif /* __RGB_V1__v */ DEMATRIX(u8_Red,u8_Green,u8_Blue,Yval_32,U_32,V_32); /* Pack 8 bit R,G,B to RGB565 */ #ifdef LITTLE_ENDIAN u32_rgb_temp2 = PACK_BGR565(0,u8_Red,u8_Green,u8_Blue); #else /* LITTLE_ENDIAN */ u32_rgb_temp2 = PACK_BGR565(16,u8_Red,u8_Green,u8_Blue); #endif /* LITTLE_ENDIAN */ pu8_src_top_Y = pu8_data_in[YPlane] + (u32_x_accum_Y >> 16) ; pu8_src_bottom_Y = pu8_src_top_Y + u32_stride_in[YPlane]; /* Weighted combination */ Y_32 = (((pu8_src_top_Y[0]*(16-u32_x_frac_Y) + pu8_src_top_Y[1]*u32_x_frac_Y) *(16-u32_y_frac_Y) + (pu8_src_bottom_Y[0]*(16-u32_x_frac_Y) + pu8_src_bottom_Y[1]*u32_x_frac_Y)*u32_y_frac_Y ) >> 8); /* YUV to RGB */ #ifdef __RGB_V1__ Yval_32 = Y_32*37; #else /* __RGB_V1__v */ Yval_32 = Y_32*0x2568; #endif /* __RGB_V1__v */ DEMATRIX(u8_Red,u8_Green,u8_Blue,Yval_32,U_32,V_32); /* Pack 8 bit R,G,B to RGB565 */ #ifdef LITTLE_ENDIAN *(pu32_rgb_data_current)++ = u32_rgb_temp1 | PACK_BGR565(16,u8_Red,u8_Green,u8_Blue); #else /* LITTLE_ENDIAN */ *(pu32_rgb_data_current)++ = u32_rgb_temp1 | PACK_BGR565(0,u8_Red,u8_Green,u8_Blue); #endif /* LITTLE_ENDIAN */ pu8_src_top_Y = pu8_data_in1[YPlane]+ (u32_x_accum_Y >> 16); pu8_src_bottom_Y = pu8_src_top_Y + u32_stride_in[YPlane]; /* Weighted combination */ Y_32 = (((pu8_src_top_Y[0]*(16-u32_x_frac_Y) + pu8_src_top_Y[1]*u32_x_frac_Y) *(16-u32_rgb_temp4) + (pu8_src_bottom_Y[0]*(16-u32_x_frac_Y) + pu8_src_bottom_Y[1]*u32_x_frac_Y)*u32_rgb_temp4 )>>8); u32_x_accum_Y += u32_x_inc[YPlane]; /* YUV to RGB */ #ifdef __RGB_V1__ Yval_32=Y_32*37; #else /* __RGB_V1__v */ Yval_32=Y_32*0x2568; #endif /* __RGB_V1__v */ DEMATRIX(u8_Red,u8_Green,u8_Blue,Yval_32,U_32,V_32); /* Pack 8 bit R,G,B to RGB565 */ #ifdef LITTLE_ENDIAN *(pu32_rgb_data_next)++ = u32_rgb_temp2 | PACK_BGR565(16,u8_Red,u8_Green,u8_Blue); #else /* LITTLE_ENDIAN */ *(pu32_rgb_data_next)++ = u32_rgb_temp2 | PACK_BGR565(0,u8_Red,u8_Green,u8_Blue); #endif /* LITTLE_ENDIAN */ } /* End of horizontal scanning */ u32_y_accum_Y = u32_rgb_temp3 + (u32_y_inc[YPlane]); u32_y_accum_U += (u32_y_inc[UPlane]); /* Y plane row update */ if (u32_y_accum_Y >> 16) { pu8_data_in[YPlane] = pu8_data_in1[YPlane] + ((u32_y_accum_Y >> 16) * (u32_stride_in[YPlane])); u32_y_accum_Y &= 0xffff; } else { pu8_data_in[YPlane] = pu8_data_in1[YPlane]; } /* U and V planes row update */ if (u32_y_accum_U >> 16) { pu8_data_in[UPlane] = pu8_data_in[UPlane] + (u32_y_accum_U >> 16) * (u32_stride_in[UPlane]); pu8_data_in[VPlane] = pu8_data_in[VPlane] + (u32_y_accum_U >> 16) * (u32_stride_in[VPlane]); u32_y_accum_U &= 0xffff; } /* BGR pointer Update */ pu32_rgb_data_start += u32_stride_out; } /* End of vertical scanning */ return M4VIFI_OK; }