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 M4VIFI_RGB565toYUV420.c
19 * @brief Contain video library function
20 * @note Color Conversion Filter
21 * -# Contains the format conversion filters from RGB565 to YUV420
22 ******************************************************************************
23 */
24
25 /* Prototypes of functions, and type definitions */
26 #include "M4VIFI_FiltersAPI.h"
27 /* Macro definitions */
28 #include "M4VIFI_Defines.h"
29 /* Clip table declaration */
30 #include "M4VIFI_Clip.h"
31
32
33 /**
34 ******************************************************************************
35 * M4VIFI_UInt8 M4VIFI_RGB565toYUV420 (void *pUserData,
36 * M4VIFI_ImagePlane *pPlaneIn,
37 * M4VIFI_ImagePlane *pPlaneOut)
38 * @brief transform RGB565 image to a YUV420 image.
39 * @note Convert RGB565 to YUV420,
40 * Loop on each row ( 2 rows by 2 rows )
41 * Loop on each column ( 2 col by 2 col )
42 * Get 4 RGB samples from input data and build 4 output Y samples
43 * and each single U & V data
44 * end loop on col
45 * end loop on row
46 * @param pUserData: (IN) User Specific Data
47 * @param pPlaneIn: (IN) Pointer to RGB565 Plane
48 * @param pPlaneOut: (OUT) Pointer to YUV420 buffer Plane
49 * @return M4VIFI_OK: there is no error
50 * @return M4VIFI_ILLEGAL_FRAME_HEIGHT: YUV Plane height is ODD
51 * @return M4VIFI_ILLEGAL_FRAME_WIDTH: YUV Plane width is ODD
52 ******************************************************************************
53 */
M4VIFI_xVSS_RGB565toYUV420(void * pUserData,M4VIFI_ImagePlane * pPlaneIn,M4VIFI_ImagePlane * pPlaneOut)54 M4VIFI_UInt8 M4VIFI_xVSS_RGB565toYUV420(void *pUserData, M4VIFI_ImagePlane *pPlaneIn,
55 M4VIFI_ImagePlane *pPlaneOut)
56 {
57 M4VIFI_UInt32 u32_width, u32_height;
58 M4VIFI_UInt32 u32_stride_Y, u32_stride2_Y, u32_stride_U, u32_stride_V;
59 M4VIFI_UInt32 u32_stride_rgb, u32_stride_2rgb;
60 M4VIFI_UInt32 u32_col, u32_row;
61
62 M4VIFI_Int32 i32_r00, i32_r01, i32_r10, i32_r11;
63 M4VIFI_Int32 i32_g00, i32_g01, i32_g10, i32_g11;
64 M4VIFI_Int32 i32_b00, i32_b01, i32_b10, i32_b11;
65 M4VIFI_Int32 i32_y00, i32_y01, i32_y10, i32_y11;
66 M4VIFI_Int32 i32_u00, i32_u01, i32_u10, i32_u11;
67 M4VIFI_Int32 i32_v00, i32_v01, i32_v10, i32_v11;
68 M4VIFI_UInt8 *pu8_yn, *pu8_ys, *pu8_u, *pu8_v;
69 M4VIFI_UInt8 *pu8_y_data, *pu8_u_data, *pu8_v_data;
70 M4VIFI_UInt8 *pu8_rgbn_data, *pu8_rgbn;
71 M4VIFI_UInt16 u16_pix1, u16_pix2, u16_pix3, u16_pix4;
72 M4VIFI_UInt8 count_null=0;
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_b00,i32_g00,i32_r00,u16_pix1);
140 /* (x+1,y) */
141 GET_RGB565(i32_b10,i32_g10,i32_r10,u16_pix2);
142 /* (x,y+1) */
143 GET_RGB565(i32_b01,i32_g01,i32_r01,u16_pix3);
144 /* (x+1,y+1) */
145 GET_RGB565(i32_b11,i32_g11,i32_r11,u16_pix4);
146 /* If RGB is transparent color (0, 63, 0), we transform it to white (31,63,31) */
147 if(i32_b00 == 0 && i32_g00 == 63 && i32_r00 == 0)
148 {
149 i32_b00 = 31;
150 i32_r00 = 31;
151 }
152 if(i32_b10 == 0 && i32_g10 == 63 && i32_r10 == 0)
153 {
154 i32_b10 = 31;
155 i32_r10 = 31;
156 }
157 if(i32_b01 == 0 && i32_g01 == 63 && i32_r01 == 0)
158 {
159 i32_b01 = 31;
160 i32_r01 = 31;
161 }
162 if(i32_b11 == 0 && i32_g11 == 63 && i32_r11 == 0)
163 {
164 i32_b11 = 31;
165 i32_r11 = 31;
166 }
167 /* Convert RGB value to YUV */
168 i32_u00 = U16(i32_r00, i32_g00, i32_b00);
169 i32_v00 = V16(i32_r00, i32_g00, i32_b00);
170 /* luminance value */
171 i32_y00 = Y16(i32_r00, i32_g00, i32_b00);
172
173 i32_u10 = U16(i32_r10, i32_g10, i32_b10);
174 i32_v10 = V16(i32_r10, i32_g10, i32_b10);
175 /* luminance value */
176 i32_y10 = Y16(i32_r10, i32_g10, i32_b10);
177
178 i32_u01 = U16(i32_r01, i32_g01, i32_b01);
179 i32_v01 = V16(i32_r01, i32_g01, i32_b01);
180 /* luminance value */
181 i32_y01 = Y16(i32_r01, i32_g01, i32_b01);
182
183 i32_u11 = U16(i32_r11, i32_g11, i32_b11);
184 i32_v11 = V16(i32_r11, i32_g11, i32_b11);
185 /* luminance value */
186 i32_y11 = Y16(i32_r11, i32_g11, i32_b11);
187
188 /* Store luminance data */
189 pu8_yn[0] = (M4VIFI_UInt8)i32_y00;
190 pu8_yn[1] = (M4VIFI_UInt8)i32_y10;
191 pu8_ys[0] = (M4VIFI_UInt8)i32_y01;
192 pu8_ys[1] = (M4VIFI_UInt8)i32_y11;
193 *pu8_u = (M4VIFI_UInt8)((i32_u00 + i32_u01 + i32_u10 + i32_u11 + 2) >> 2);
194 *pu8_v = (M4VIFI_UInt8)((i32_v00 + i32_v01 + i32_v10 + i32_v11 + 2) >> 2);
195 /* Prepare for next column */
196 pu8_rgbn += (CST_RGB_16_SIZE<<1);
197 /* Update current Y plane line pointer*/
198 pu8_yn += 2;
199 /* Update next Y plane line pointer*/
200 pu8_ys += 2;
201 /* Update U plane line pointer*/
202 pu8_u ++;
203 /* Update V plane line pointer*/
204 pu8_v ++;
205 } /* End of horizontal scanning */
206
207 /* Prepare pointers for the next row */
208 pu8_y_data += u32_stride2_Y;
209 pu8_u_data += u32_stride_U;
210 pu8_v_data += u32_stride_V;
211 pu8_rgbn_data += u32_stride_2rgb;
212
213
214 } /* End of vertical scanning */
215
216 return M4VIFI_OK;
217 }
218 /* End of file M4VIFI_RGB565toYUV420.c */
219
220