summaryrefslogtreecommitdiff
path: root/v3/Converters.h (plain)
blob: 13e2a854085e3f00770adadc6ed6b90af4c7359c
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#ifndef HW_EMULATOR_CAMERA_CONVERTERS_H
18#define HW_EMULATOR_CAMERA_CONVERTERS_H
19
20#include <endian.h>
21
22#ifndef __BYTE_ORDER
23#error "could not determine byte order"
24#endif
25
26/*
27 * Contains declaration of framebuffer conversion routines.
28 *
29 * NOTE: RGB and big/little endian considerations. Wherewer in this code RGB
30 * pixels are represented as WORD, or DWORD, the color order inside the
31 * WORD / DWORD matches the one that would occur if that WORD / DWORD would have
32 * been read from the typecasted framebuffer:
33 *
34 * const uint32_t rgb = *reinterpret_cast<const uint32_t*>(framebuffer);
35 *
36 * So, if this code runs on the little endian CPU, red color in 'rgb' would be
37 * masked as 0x000000ff, and blue color would be masked as 0x00ff0000, while if
38 * the code runs on a big endian CPU, the red color in 'rgb' would be masked as
39 * 0xff000000, and blue color would be masked as 0x0000ff00,
40 */
41
42namespace android {
43
44/*
45 * RGB565 color masks
46 */
47
48#if __BYTE_ORDER == __LITTLE_ENDIAN
49static const uint16_t kRed5 = 0x001f;
50static const uint16_t kGreen6 = 0x07e0;
51static const uint16_t kBlue5 = 0xf800;
52#else // __BYTE_ORDER
53static const uint16_t kRed5 = 0xf800;
54static const uint16_t kGreen6 = 0x07e0;
55static const uint16_t kBlue5 = 0x001f;
56#endif // __BYTE_ORDER
57static const uint32_t kBlack16 = 0x0000;
58static const uint32_t kWhite16 = kRed5 | kGreen6 | kBlue5;
59
60/*
61 * RGB32 color masks
62 */
63
64#if __BYTE_ORDER == __LITTLE_ENDIAN
65static const uint32_t kRed8 = 0x000000ff;
66static const uint32_t kGreen8 = 0x0000ff00;
67static const uint32_t kBlue8 = 0x00ff0000;
68#else // __BYTE_ORDER
69static const uint32_t kRed8 = 0x00ff0000;
70static const uint32_t kGreen8 = 0x0000ff00;
71static const uint32_t kBlue8 = 0x000000ff;
72#endif // __BYTE_ORDER
73static const uint32_t kBlack32 = 0x00000000;
74static const uint32_t kWhite32 = kRed8 | kGreen8 | kBlue8;
75
76/*
77 * Extracting, and saving color bytes from / to WORD / DWORD RGB.
78 */
79
80#if __BYTE_ORDER == __LITTLE_ENDIAN
81/* Extract red, green, and blue bytes from RGB565 word. */
82#define R16(rgb) static_cast<uint8_t>(rgb & kRed5)
83#define G16(rgb) static_cast<uint8_t>((rgb & kGreen6) >> 5)
84#define B16(rgb) static_cast<uint8_t>((rgb & kBlue5) >> 11)
85/* Make 8 bits red, green, and blue, extracted from RGB565 word. */
86#define R16_32(rgb) static_cast<uint8_t>(((rgb & kRed5) << 3) | ((rgb & kRed5) >> 2))
87#define G16_32(rgb) static_cast<uint8_t>(((rgb & kGreen6) >> 3) | ((rgb & kGreen6) >> 9))
88#define B16_32(rgb) static_cast<uint8_t>(((rgb & kBlue5) >> 8) | ((rgb & kBlue5) >> 14))
89/* Extract red, green, and blue bytes from RGB32 dword. */
90#define R32(rgb) static_cast<uint8_t>(rgb & kRed8)
91#define G32(rgb) static_cast<uint8_t>(((rgb & kGreen8) >> 8) & 0xff)
92#define B32(rgb) static_cast<uint8_t>(((rgb & kBlue8) >> 16) & 0xff)
93/* Build RGB565 word from red, green, and blue bytes. */
94#define RGB565(r, g, b) static_cast<uint16_t>((((static_cast<uint16_t>(b) << 6) | g) << 5) | r)
95/* Build RGB32 dword from red, green, and blue bytes. */
96#define RGB32(r, g, b) static_cast<uint32_t>((((static_cast<uint32_t>(b) << 8) | g) << 8) | r)
97#else // __BYTE_ORDER
98/* Extract red, green, and blue bytes from RGB565 word. */
99#define R16(rgb) static_cast<uint8_t>((rgb & kRed5) >> 11)
100#define G16(rgb) static_cast<uint8_t>((rgb & kGreen6) >> 5)
101#define B16(rgb) static_cast<uint8_t>(rgb & kBlue5)
102/* Make 8 bits red, green, and blue, extracted from RGB565 word. */
103#define R16_32(rgb) static_cast<uint8_t>(((rgb & kRed5) >> 8) | ((rgb & kRed5) >> 14))
104#define G16_32(rgb) static_cast<uint8_t>(((rgb & kGreen6) >> 3) | ((rgb & kGreen6) >> 9))
105#define B16_32(rgb) static_cast<uint8_t>(((rgb & kBlue5) << 3) | ((rgb & kBlue5) >> 2))
106/* Extract red, green, and blue bytes from RGB32 dword. */
107#define R32(rgb) static_cast<uint8_t>((rgb & kRed8) >> 16)
108#define G32(rgb) static_cast<uint8_t>((rgb & kGreen8) >> 8)
109#define B32(rgb) static_cast<uint8_t>(rgb & kBlue8)
110/* Build RGB565 word from red, green, and blue bytes. */
111#define RGB565(r, g, b) static_cast<uint16_t>((((static_cast<uint16_t>(r) << 6) | g) << 5) | b)
112/* Build RGB32 dword from red, green, and blue bytes. */
113#define RGB32(r, g, b) static_cast<uint32_t>((((static_cast<uint32_t>(r) << 8) | g) << 8) | b)
114#endif // __BYTE_ORDER
115
116/* An union that simplifies breaking 32 bit RGB into separate R, G, and B colors.
117 */
118typedef union RGB32_t {
119 uint32_t color;
120 struct {
121#if __BYTE_ORDER == __LITTLE_ENDIAN
122 uint8_t r; uint8_t g; uint8_t b; uint8_t a;
123#else // __BYTE_ORDER
124 uint8_t a; uint8_t b; uint8_t g; uint8_t r;
125#endif // __BYTE_ORDER
126 };
127} RGB32_t;
128
129
130/* Clips a value to the unsigned 0-255 range, treating negative values as zero.
131 */
132static __inline__ int
133clamp(int x)
134{
135 if (x > 255) return 255;
136 if (x < 0) return 0;
137 return x;
138}
139
140/********************************************************************************
141 * Basics of RGB -> YUV conversion
142 *******************************************************************************/
143
144/*
145 * RGB -> YUV conversion macros
146 */
147#define RGB2Y(r, g, b) (uint8_t)(((66 * (r) + 129 * (g) + 25 * (b) + 128) >> 8) + 16)
148#define RGB2U(r, g, b) (uint8_t)(((-38 * (r) - 74 * (g) + 112 * (b) + 128) >> 8) + 128)
149#define RGB2V(r, g, b) (uint8_t)(((112 * (r) - 94 * (g) - 18 * (b) + 128) >> 8) + 128)
150
151/* Converts R8 G8 B8 color to YUV. */
152static __inline__ void
153R8G8B8ToYUV(uint8_t r, uint8_t g, uint8_t b, uint8_t* y, uint8_t* u, uint8_t* v)
154{
155 *y = RGB2Y((int)r, (int)g, (int)b);
156 *u = RGB2U((int)r, (int)g, (int)b);
157 *v = RGB2V((int)r, (int)g, (int)b);
158}
159
160/* Converts RGB565 color to YUV. */
161static __inline__ void
162RGB565ToYUV(uint16_t rgb, uint8_t* y, uint8_t* u, uint8_t* v)
163{
164 R8G8B8ToYUV(R16_32(rgb), G16_32(rgb), B16_32(rgb), y, u, v);
165}
166
167/* Converts RGB32 color to YUV. */
168static __inline__ void
169RGB32ToYUV(uint32_t rgb, uint8_t* y, uint8_t* u, uint8_t* v)
170{
171 RGB32_t rgb_c;
172 rgb_c.color = rgb;
173 R8G8B8ToYUV(rgb_c.r, rgb_c.g, rgb_c.b, y, u, v);
174}
175
176/********************************************************************************
177 * Basics of YUV -> RGB conversion.
178 * Note that due to the fact that guest uses RGB only on preview window, and the
179 * RGB format that is used is RGB565, we can limit YUV -> RGB conversions to
180 * RGB565 only.
181 *******************************************************************************/
182
183/*
184 * YUV -> RGB conversion macros
185 */
186
187/* "Optimized" macros that take specialy prepared Y, U, and V values:
188 * C = Y - 16
189 * D = U - 128
190 * E = V - 128
191 */
192#define YUV2RO(C, D, E) clamp((298 * (C) + 409 * (E) + 128) >> 8)
193#define YUV2GO(C, D, E) clamp((298 * (C) - 100 * (D) - 208 * (E) + 128) >> 8)
194#define YUV2BO(C, D, E) clamp((298 * (C) + 516 * (D) + 128) >> 8)
195
196/*
197 * Main macros that take the original Y, U, and V values
198 */
199#define YUV2R(y, u, v) clamp((298 * ((y)-16) + 409 * ((v)-128) + 128) >> 8)
200#define YUV2G(y, u, v) clamp((298 * ((y)-16) - 100 * ((u)-128) - 208 * ((v)-128) + 128) >> 8)
201#define YUV2B(y, u, v) clamp((298 * ((y)-16) + 516 * ((u)-128) + 128) >> 8)
202
203
204/* Converts YUV color to RGB565. */
205static __inline__ uint16_t
206YUVToRGB565(int y, int u, int v)
207{
208 /* Calculate C, D, and E values for the optimized macro. */
209 y -= 16; u -= 128; v -= 128;
210 const uint16_t r = (YUV2RO(y,u,v) >> 3) & 0x1f;
211 const uint16_t g = (YUV2GO(y,u,v) >> 2) & 0x3f;
212 const uint16_t b = (YUV2BO(y,u,v) >> 3) & 0x1f;
213 return RGB565(r, g, b);
214}
215
216/* Converts YUV color to RGB32. */
217static __inline__ uint32_t
218YUVToRGB32(int y, int u, int v)
219{
220 /* Calculate C, D, and E values for the optimized macro. */
221 y -= 16; u -= 128; v -= 128;
222 RGB32_t rgb;
223 rgb.r = YUV2RO(y,u,v) & 0xff;
224 rgb.g = YUV2GO(y,u,v) & 0xff;
225 rgb.b = YUV2BO(y,u,v) & 0xff;
226 return rgb.color;
227}
228
229/* YUV pixel descriptor. */
230struct YUVPixel {
231 uint8_t Y;
232 uint8_t U;
233 uint8_t V;
234
235 inline YUVPixel()
236 : Y(0), U(0), V(0)
237 {
238 }
239
240 inline explicit YUVPixel(uint16_t rgb565)
241 {
242 RGB565ToYUV(rgb565, &Y, &U, &V);
243 }
244
245 inline explicit YUVPixel(uint32_t rgb32)
246 {
247 RGB32ToYUV(rgb32, &Y, &U, &V);
248 }
249
250 inline void get(uint8_t* pY, uint8_t* pU, uint8_t* pV) const
251 {
252 *pY = Y; *pU = U; *pV = V;
253 }
254};
255
256/* Converts an YV12 framebuffer to RGB565 framebuffer.
257 * Param:
258 * yv12 - YV12 framebuffer.
259 * rgb - RGB565 framebuffer.
260 * width, height - Dimensions for both framebuffers.
261 */
262void YV12ToRGB565(const void* yv12, void* rgb, int width, int height);
263
264/* Converts an YV12 framebuffer to RGB32 framebuffer.
265 * Param:
266 * yv12 - YV12 framebuffer.
267 * rgb - RGB32 framebuffer.
268 * width, height - Dimensions for both framebuffers.
269 */
270void YV12ToRGB32(const void* yv12, void* rgb, int width, int height);
271
272/* Converts an YU12 framebuffer to RGB32 framebuffer.
273 * Param:
274 * yu12 - YU12 framebuffer.
275 * rgb - RGB32 framebuffer.
276 * width, height - Dimensions for both framebuffers.
277 */
278void YU12ToRGB32(const void* yu12, void* rgb, int width, int height);
279
280/* Converts an NV12 framebuffer to RGB565 framebuffer.
281 * Param:
282 * nv12 - NV12 framebuffer.
283 * rgb - RGB565 framebuffer.
284 * width, height - Dimensions for both framebuffers.
285 */
286void NV12ToRGB565(const void* nv12, void* rgb, int width, int height);
287
288/* Converts an NV12 framebuffer to RGB32 framebuffer.
289 * Param:
290 * nv12 - NV12 framebuffer.
291 * rgb - RGB32 framebuffer.
292 * width, height - Dimensions for both framebuffers.
293 */
294void NV12ToRGB32(const void* nv12, void* rgb, int width, int height);
295
296/* Converts an NV21 framebuffer to RGB565 framebuffer.
297 * Param:
298 * nv21 - NV21 framebuffer.
299 * rgb - RGB565 framebuffer.
300 * width, height - Dimensions for both framebuffers.
301 */
302void NV21ToRGB565(const void* nv21, void* rgb, int width, int height);
303
304/* Converts an NV21 framebuffer to RGB32 framebuffer.
305 * Param:
306 * nv21 - NV21 framebuffer.
307 * rgb - RGB32 framebuffer.
308 * width, height - Dimensions for both framebuffers.
309 */
310void NV21ToRGB32(const void* nv21, void* rgb, int width, int height);
311
312}; /* namespace android */
313
314#endif /* HW_EMULATOR_CAMERA_CONVERTERS_H */
315
generated by cgit at 2024-05-18 21:29:06 (GMT)