M4VIFI_RGB565toYUV420.c revision 0078736220b9372f2c82eb258ceca3dbd6c358ef 
1/*
2 * Copyright (C) 2004-2011 NXP Software
3 * Copyright (C) 2011 The Android Open Source Project
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/**
19 ******************************************************************************
20 * @brief    Contain video library function
21 * @note     Color Conversion Filter
22 *           Contains the format conversion filters from RGB565 to YUV420
23 ******************************************************************************
24*/
25
26/* Prototypes of functions, and type definitions */
27#include    "M4VIFI_FiltersAPI.h"
28/* Macro definitions */
29#include    "M4VIFI_Defines.h"
30/* Clip table declaration */
31#include    "M4VIFI_Clip.h"
32
33
34/**
35 ******************************************************************************
36 * M4VIFI_UInt8 M4VIFI_RGB565toYUV420 (void *pUserData,
37 *                                   M4VIFI_ImagePlane *pPlaneIn,
38 *                                   M4VIFI_ImagePlane *pPlaneOut)
39 * @brief   transform RGB565 image to a YUV420 image.
40 * @note    Convert RGB565 to YUV420,
41 *          Loop on each row ( 2 rows by 2 rows )
42 *              Loop on each column ( 2 col by 2 col )
43 *                  Get 4 RGB samples from input data and build 4 output Y samples
44 *                  and each single U & V data
45 *              end loop on col
46 *          end loop on row
47 * @param   pUserData: (IN) User Specific Data
48 * @param   pPlaneIn: (IN) Pointer to RGB565 Plane
49 * @param   pPlaneOut: (OUT) Pointer to  YUV420 buffer Plane
50 * @return  M4VIFI_OK: there is no error
51 * @return  M4VIFI_ILLEGAL_FRAME_HEIGHT: YUV Plane height is ODD
52 * @return  M4VIFI_ILLEGAL_FRAME_WIDTH:  YUV Plane width is ODD
53 ******************************************************************************
54*/
55M4VIFI_UInt8    M4VIFI_RGB565toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn,
56                                                      M4VIFI_ImagePlane *pPlaneOut)
57{
58    M4VIFI_UInt32   u32_width, u32_height;
59    M4VIFI_UInt32   u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V;
60    M4VIFI_UInt32   u32_stride_rgb, u32_stride_2rgb;
61    M4VIFI_UInt32   u32_col, u32_row;
62
63    M4VIFI_Int32    i32_r00, i32_r01, i32_r10, i32_r11;
64    M4VIFI_Int32    i32_g00, i32_g01, i32_g10, i32_g11;
65    M4VIFI_Int32    i32_b00, i32_b01, i32_b10, i32_b11;
66    M4VIFI_Int32    i32_y00, i32_y01, i32_y10, i32_y11;
67    M4VIFI_Int32    i32_u00, i32_u01, i32_u10, i32_u11;
68    M4VIFI_Int32    i32_v00, i32_v01, i32_v10, i32_v11;
69    M4VIFI_UInt8    *pu8_yn, *pu8_ys, *pu8_u, *pu8_v;
70    M4VIFI_UInt8    *pu8_y_data, *pu8_u_data, *pu8_v_data;
71    M4VIFI_UInt8    *pu8_rgbn_data, *pu8_rgbn;
72    M4VIFI_UInt16   u16_pix1, u16_pix2, u16_pix3, u16_pix4;
73
74    /* Check planes height are appropriate */
75    if ((pPlaneIn->u_height != pPlaneOut[0].u_height)           ||
76        (pPlaneOut[0].u_height != (pPlaneOut[1].u_height<<1))   ||
77        (pPlaneOut[0].u_height != (pPlaneOut[2].u_height<<1)))
78    {
79        return M4VIFI_ILLEGAL_FRAME_HEIGHT;
80    }
81
82    /* Check planes width are appropriate */
83    if ((pPlaneIn->u_width != pPlaneOut[0].u_width)         ||
84        (pPlaneOut[0].u_width != (pPlaneOut[1].u_width<<1)) ||
85        (pPlaneOut[0].u_width != (pPlaneOut[2].u_width<<1)))
86    {
87        return M4VIFI_ILLEGAL_FRAME_WIDTH;
88    }
89
90    /* Set the pointer to the beginning of the output data buffers */
91    pu8_y_data = pPlaneOut[0].pac_data + pPlaneOut[0].u_topleft;
92    pu8_u_data = pPlaneOut[1].pac_data + pPlaneOut[1].u_topleft;
93    pu8_v_data = pPlaneOut[2].pac_data + pPlaneOut[2].u_topleft;
94
95    /* Set the pointer to the beginning of the input data buffers */
96    pu8_rgbn_data   = pPlaneIn->pac_data + pPlaneIn->u_topleft;
97
98    /* Get the size of the output image */
99    u32_width = pPlaneOut[0].u_width;
100    u32_height = pPlaneOut[0].u_height;
101
102    /* Set the size of the memory jumps corresponding to row jump in each output plane */
103    u32_stride_Y = pPlaneOut[0].u_stride;
104    u32_stride2_Y = u32_stride_Y << 1;
105    u32_stride_U = pPlaneOut[1].u_stride;
106    u32_stride_V = pPlaneOut[2].u_stride;
107
108    /* Set the size of the memory jumps corresponding to row jump in input plane */
109    u32_stride_rgb = pPlaneIn->u_stride;
110    u32_stride_2rgb = u32_stride_rgb << 1;
111
112
113    /* Loop on each row of the output image, input coordinates are estimated from output ones */
114    /* Two YUV rows are computed at each pass */
115    for (u32_row = u32_height ;u32_row != 0; u32_row -=2)
116    {
117        /* Current Y plane row pointers */
118        pu8_yn = pu8_y_data;
119        /* Next Y plane row pointers */
120        pu8_ys = pu8_yn + u32_stride_Y;
121        /* Current U plane row pointer */
122        pu8_u = pu8_u_data;
123        /* Current V plane row pointer */
124        pu8_v = pu8_v_data;
125
126        pu8_rgbn = pu8_rgbn_data;
127
128        /* Loop on each column of the output image */
129        for (u32_col = u32_width; u32_col != 0 ; u32_col -=2)
130        {
131            /* Get four RGB 565 samples from input data */
132            u16_pix1 = *( (M4VIFI_UInt16 *) pu8_rgbn);
133            u16_pix2 = *( (M4VIFI_UInt16 *) (pu8_rgbn + CST_RGB_16_SIZE));
134            u16_pix3 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb));
135            u16_pix4 = *( (M4VIFI_UInt16 *) (pu8_rgbn + u32_stride_rgb + CST_RGB_16_SIZE));
136
137            /* Unpack RGB565 to 8bit R, G, B */
138            /* (x,y) */
139            GET_RGB565(i32_r00,i32_g00,i32_b00,u16_pix1);
140            /* (x+1,y) */
141            GET_RGB565(i32_r10,i32_g10,i32_b10,u16_pix2);
142            /* (x,y+1) */
143            GET_RGB565(i32_r01,i32_g01,i32_b01,u16_pix3);
144            /* (x+1,y+1) */
145            GET_RGB565(i32_r11,i32_g11,i32_b11,u16_pix4);
146
147            /* Convert RGB value to YUV */
148            i32_u00 = U16(i32_r00, i32_g00, i32_b00);
149            i32_v00 = V16(i32_r00, i32_g00, i32_b00);
150            /* luminance value */
151            i32_y00 = Y16(i32_r00, i32_g00, i32_b00);
152
153            i32_u10 = U16(i32_r10, i32_g10, i32_b10);
154            i32_v10 = V16(i32_r10, i32_g10, i32_b10);
155            /* luminance value */
156            i32_y10 = Y16(i32_r10, i32_g10, i32_b10);
157
158            i32_u01 = U16(i32_r01, i32_g01, i32_b01);
159            i32_v01 = V16(i32_r01, i32_g01, i32_b01);
160            /* luminance value */
161            i32_y01 = Y16(i32_r01, i32_g01, i32_b01);
162
163            i32_u11 = U16(i32_r11, i32_g11, i32_b11);
164            i32_v11 = V16(i32_r11, i32_g11, i32_b11);
165            /* luminance value */
166            i32_y11 = Y16(i32_r11, i32_g11, i32_b11);
167
168            /* Store luminance data */
169            pu8_yn[0] = (M4VIFI_UInt8)i32_y00;
170            pu8_yn[1] = (M4VIFI_UInt8)i32_y10;
171            pu8_ys[0] = (M4VIFI_UInt8)i32_y01;
172            pu8_ys[1] = (M4VIFI_UInt8)i32_y11;
173
174            /* Store chroma data */
175            *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2);
176            *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2);
177
178            /* Prepare for next column */
179            pu8_rgbn += (CST_RGB_16_SIZE<<1);
180            /* Update current Y plane line pointer*/
181            pu8_yn += 2;
182            /* Update next Y plane line pointer*/
183            pu8_ys += 2;
184            /* Update U plane line pointer*/
185            pu8_u ++;
186            /* Update V plane line pointer*/
187            pu8_v ++;
188        } /* End of horizontal scanning */
189
190        /* Prepare pointers for the next row */
191        pu8_y_data += u32_stride2_Y;
192        pu8_u_data += u32_stride_U;
193        pu8_v_data += u32_stride_V;
194        pu8_rgbn_data += u32_stride_2rgb;
195
196
197    } /* End of vertical scanning */
198
199    return M4VIFI_OK;
200}
201
202
203