media/libyuv/source/format_conversion.cc@6474c204b198
media/libyuv/source/format_conversion.cc
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rw-r--r--
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
1 /*
2 * Copyright 2011 The LibYuv Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
11 #include "libyuv/format_conversion.h"
13 #include "libyuv/basic_types.h"
14 #include "libyuv/cpu_id.h"
15 #include "libyuv/video_common.h"
16 #include "libyuv/row.h"
18 #ifdef __cplusplus
19 namespace libyuv {
20 extern "C" {
21 #endif
23 // generate a selector mask useful for pshufb
24 static uint32 GenerateSelector(int select0, int select1) {
25 return (uint32)(select0) |
26 (uint32)((select1 + 4) << 8) |
27 (uint32)((select0 + 8) << 16) |
28 (uint32)((select1 + 12) << 24);
29 }
31 static int MakeSelectors(const int blue_index,
32 const int green_index,
33 const int red_index,
34 uint32 dst_fourcc_bayer,
35 uint32* index_map) {
36 // Now build a lookup table containing the indices for the four pixels in each
37 // 2x2 Bayer grid.
38 switch (dst_fourcc_bayer) {
39 case FOURCC_BGGR:
40 index_map[0] = GenerateSelector(blue_index, green_index);
41 index_map[1] = GenerateSelector(green_index, red_index);
42 break;
43 case FOURCC_GBRG:
44 index_map[0] = GenerateSelector(green_index, blue_index);
45 index_map[1] = GenerateSelector(red_index, green_index);
46 break;
47 case FOURCC_RGGB:
48 index_map[0] = GenerateSelector(red_index, green_index);
49 index_map[1] = GenerateSelector(green_index, blue_index);
50 break;
51 case FOURCC_GRBG:
52 index_map[0] = GenerateSelector(green_index, red_index);
53 index_map[1] = GenerateSelector(blue_index, green_index);
54 break;
55 default:
56 return -1; // Bad FourCC
57 }
58 return 0;
59 }
61 // Converts 32 bit ARGB to Bayer RGB formats.
62 LIBYUV_API
63 int ARGBToBayer(const uint8* src_argb, int src_stride_argb,
64 uint8* dst_bayer, int dst_stride_bayer,
65 int width, int height,
66 uint32 dst_fourcc_bayer) {
67 if (height < 0) {
68 height = -height;
69 src_argb = src_argb + (height - 1) * src_stride_argb;
70 src_stride_argb = -src_stride_argb;
71 }
72 void (*ARGBToBayerRow)(const uint8* src_argb, uint8* dst_bayer,
73 uint32 selector, int pix) = ARGBToBayerRow_C;
74 #if defined(HAS_ARGBTOBAYERROW_SSSE3)
75 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8 &&
76 IS_ALIGNED(src_argb, 16) && IS_ALIGNED(src_stride_argb, 16)) {
77 ARGBToBayerRow = ARGBToBayerRow_Any_SSSE3;
78 if (IS_ALIGNED(width, 8)) {
79 ARGBToBayerRow = ARGBToBayerRow_SSSE3;
80 }
81 }
82 #elif defined(HAS_ARGBTOBAYERROW_NEON)
83 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
84 ARGBToBayerRow = ARGBToBayerRow_Any_NEON;
85 if (IS_ALIGNED(width, 8)) {
86 ARGBToBayerRow = ARGBToBayerRow_NEON;
87 }
88 }
89 #endif
90 const int blue_index = 0; // Offsets for ARGB format
91 const int green_index = 1;
92 const int red_index = 2;
93 uint32 index_map[2];
94 if (MakeSelectors(blue_index, green_index, red_index,
95 dst_fourcc_bayer, index_map)) {
96 return -1; // Bad FourCC
97 }
99 for (int y = 0; y < height; ++y) {
100 ARGBToBayerRow(src_argb, dst_bayer, index_map[y & 1], width);
101 src_argb += src_stride_argb;
102 dst_bayer += dst_stride_bayer;
103 }
104 return 0;
105 }
107 #define AVG(a, b) (((a) + (b)) >> 1)
109 static void BayerRowBG(const uint8* src_bayer0, int src_stride_bayer,
110 uint8* dst_argb, int pix) {
111 const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
112 uint8 g = src_bayer0[1];
113 uint8 r = src_bayer1[1];
114 for (int x = 0; x < pix - 2; x += 2) {
115 dst_argb[0] = src_bayer0[0];
116 dst_argb[1] = AVG(g, src_bayer0[1]);
117 dst_argb[2] = AVG(r, src_bayer1[1]);
118 dst_argb[3] = 255U;
119 dst_argb[4] = AVG(src_bayer0[0], src_bayer0[2]);
120 dst_argb[5] = src_bayer0[1];
121 dst_argb[6] = src_bayer1[1];
122 dst_argb[7] = 255U;
123 g = src_bayer0[1];
124 r = src_bayer1[1];
125 src_bayer0 += 2;
126 src_bayer1 += 2;
127 dst_argb += 8;
128 }
129 dst_argb[0] = src_bayer0[0];
130 dst_argb[1] = AVG(g, src_bayer0[1]);
131 dst_argb[2] = AVG(r, src_bayer1[1]);
132 dst_argb[3] = 255U;
133 if (!(pix & 1)) {
134 dst_argb[4] = src_bayer0[0];
135 dst_argb[5] = src_bayer0[1];
136 dst_argb[6] = src_bayer1[1];
137 dst_argb[7] = 255U;
138 }
139 }
141 static void BayerRowRG(const uint8* src_bayer0, int src_stride_bayer,
142 uint8* dst_argb, int pix) {
143 const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
144 uint8 g = src_bayer0[1];
145 uint8 b = src_bayer1[1];
146 for (int x = 0; x < pix - 2; x += 2) {
147 dst_argb[0] = AVG(b, src_bayer1[1]);
148 dst_argb[1] = AVG(g, src_bayer0[1]);
149 dst_argb[2] = src_bayer0[0];
150 dst_argb[3] = 255U;
151 dst_argb[4] = src_bayer1[1];
152 dst_argb[5] = src_bayer0[1];
153 dst_argb[6] = AVG(src_bayer0[0], src_bayer0[2]);
154 dst_argb[7] = 255U;
155 g = src_bayer0[1];
156 b = src_bayer1[1];
157 src_bayer0 += 2;
158 src_bayer1 += 2;
159 dst_argb += 8;
160 }
161 dst_argb[0] = AVG(b, src_bayer1[1]);
162 dst_argb[1] = AVG(g, src_bayer0[1]);
163 dst_argb[2] = src_bayer0[0];
164 dst_argb[3] = 255U;
165 if (!(pix & 1)) {
166 dst_argb[4] = src_bayer1[1];
167 dst_argb[5] = src_bayer0[1];
168 dst_argb[6] = src_bayer0[0];
169 dst_argb[7] = 255U;
170 }
171 }
173 static void BayerRowGB(const uint8* src_bayer0, int src_stride_bayer,
174 uint8* dst_argb, int pix) {
175 const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
176 uint8 b = src_bayer0[1];
177 for (int x = 0; x < pix - 2; x += 2) {
178 dst_argb[0] = AVG(b, src_bayer0[1]);
179 dst_argb[1] = src_bayer0[0];
180 dst_argb[2] = src_bayer1[0];
181 dst_argb[3] = 255U;
182 dst_argb[4] = src_bayer0[1];
183 dst_argb[5] = AVG(src_bayer0[0], src_bayer0[2]);
184 dst_argb[6] = AVG(src_bayer1[0], src_bayer1[2]);
185 dst_argb[7] = 255U;
186 b = src_bayer0[1];
187 src_bayer0 += 2;
188 src_bayer1 += 2;
189 dst_argb += 8;
190 }
191 dst_argb[0] = AVG(b, src_bayer0[1]);
192 dst_argb[1] = src_bayer0[0];
193 dst_argb[2] = src_bayer1[0];
194 dst_argb[3] = 255U;
195 if (!(pix & 1)) {
196 dst_argb[4] = src_bayer0[1];
197 dst_argb[5] = src_bayer0[0];
198 dst_argb[6] = src_bayer1[0];
199 dst_argb[7] = 255U;
200 }
201 }
203 static void BayerRowGR(const uint8* src_bayer0, int src_stride_bayer,
204 uint8* dst_argb, int pix) {
205 const uint8* src_bayer1 = src_bayer0 + src_stride_bayer;
206 uint8 r = src_bayer0[1];
207 for (int x = 0; x < pix - 2; x += 2) {
208 dst_argb[0] = src_bayer1[0];
209 dst_argb[1] = src_bayer0[0];
210 dst_argb[2] = AVG(r, src_bayer0[1]);
211 dst_argb[3] = 255U;
212 dst_argb[4] = AVG(src_bayer1[0], src_bayer1[2]);
213 dst_argb[5] = AVG(src_bayer0[0], src_bayer0[2]);
214 dst_argb[6] = src_bayer0[1];
215 dst_argb[7] = 255U;
216 r = src_bayer0[1];
217 src_bayer0 += 2;
218 src_bayer1 += 2;
219 dst_argb += 8;
220 }
221 dst_argb[0] = src_bayer1[0];
222 dst_argb[1] = src_bayer0[0];
223 dst_argb[2] = AVG(r, src_bayer0[1]);
224 dst_argb[3] = 255U;
225 if (!(pix & 1)) {
226 dst_argb[4] = src_bayer1[0];
227 dst_argb[5] = src_bayer0[0];
228 dst_argb[6] = src_bayer0[1];
229 dst_argb[7] = 255U;
230 }
231 }
233 // Converts any Bayer RGB format to ARGB.
234 LIBYUV_API
235 int BayerToARGB(const uint8* src_bayer, int src_stride_bayer,
236 uint8* dst_argb, int dst_stride_argb,
237 int width, int height,
238 uint32 src_fourcc_bayer) {
239 if (height < 0) {
240 height = -height;
241 dst_argb = dst_argb + (height - 1) * dst_stride_argb;
242 dst_stride_argb = -dst_stride_argb;
243 }
244 void (*BayerRow0)(const uint8* src_bayer, int src_stride_bayer,
245 uint8* dst_argb, int pix);
246 void (*BayerRow1)(const uint8* src_bayer, int src_stride_bayer,
247 uint8* dst_argb, int pix);
248 switch (src_fourcc_bayer) {
249 case FOURCC_BGGR:
250 BayerRow0 = BayerRowBG;
251 BayerRow1 = BayerRowGR;
252 break;
253 case FOURCC_GBRG:
254 BayerRow0 = BayerRowGB;
255 BayerRow1 = BayerRowRG;
256 break;
257 case FOURCC_GRBG:
258 BayerRow0 = BayerRowGR;
259 BayerRow1 = BayerRowBG;
260 break;
261 case FOURCC_RGGB:
262 BayerRow0 = BayerRowRG;
263 BayerRow1 = BayerRowGB;
264 break;
265 default:
266 return -1; // Bad FourCC
267 }
269 for (int y = 0; y < height - 1; y += 2) {
270 BayerRow0(src_bayer, src_stride_bayer, dst_argb, width);
271 BayerRow1(src_bayer + src_stride_bayer, -src_stride_bayer,
272 dst_argb + dst_stride_argb, width);
273 src_bayer += src_stride_bayer * 2;
274 dst_argb += dst_stride_argb * 2;
275 }
276 if (height & 1) {
277 BayerRow0(src_bayer, src_stride_bayer, dst_argb, width);
278 }
279 return 0;
280 }
282 // Converts any Bayer RGB format to ARGB.
283 LIBYUV_API
284 int BayerToI420(const uint8* src_bayer, int src_stride_bayer,
285 uint8* dst_y, int dst_stride_y,
286 uint8* dst_u, int dst_stride_u,
287 uint8* dst_v, int dst_stride_v,
288 int width, int height,
289 uint32 src_fourcc_bayer) {
290 // Negative height means invert the image.
291 if (height < 0) {
292 height = -height;
293 int halfheight = (height + 1) >> 1;
294 dst_y = dst_y + (height - 1) * dst_stride_y;
295 dst_u = dst_u + (halfheight - 1) * dst_stride_u;
296 dst_v = dst_v + (halfheight - 1) * dst_stride_v;
297 dst_stride_y = -dst_stride_y;
298 dst_stride_u = -dst_stride_u;
299 dst_stride_v = -dst_stride_v;
300 }
301 void (*BayerRow0)(const uint8* src_bayer, int src_stride_bayer,
302 uint8* dst_argb, int pix);
303 void (*BayerRow1)(const uint8* src_bayer, int src_stride_bayer,
304 uint8* dst_argb, int pix);
306 void (*ARGBToUVRow)(const uint8* src_argb0, int src_stride_argb,
307 uint8* dst_u, uint8* dst_v, int width) = ARGBToUVRow_C;
308 void (*ARGBToYRow)(const uint8* src_argb, uint8* dst_y, int pix) =
309 ARGBToYRow_C;
310 #if defined(HAS_ARGBTOYROW_SSSE3) && defined(HAS_ARGBTOUVROW_SSSE3)
311 if (TestCpuFlag(kCpuHasSSSE3) && width >= 16) {
312 ARGBToUVRow = ARGBToUVRow_Any_SSSE3;
313 ARGBToYRow = ARGBToYRow_Any_SSSE3;
314 if (IS_ALIGNED(width, 16)) {
315 ARGBToYRow = ARGBToYRow_Unaligned_SSSE3;
316 ARGBToUVRow = ARGBToUVRow_SSSE3;
317 if (IS_ALIGNED(dst_y, 16) && IS_ALIGNED(dst_stride_y, 16)) {
318 ARGBToYRow = ARGBToYRow_SSSE3;
319 }
320 }
321 }
322 #elif defined(HAS_ARGBTOYROW_NEON)
323 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
324 ARGBToYRow = ARGBToYRow_Any_NEON;
325 if (IS_ALIGNED(width, 8)) {
326 ARGBToYRow = ARGBToYRow_NEON;
327 }
328 if (width >= 16) {
329 ARGBToUVRow = ARGBToUVRow_Any_NEON;
330 if (IS_ALIGNED(width, 16)) {
331 ARGBToUVRow = ARGBToUVRow_NEON;
332 }
333 }
334 }
335 #endif
337 switch (src_fourcc_bayer) {
338 case FOURCC_BGGR:
339 BayerRow0 = BayerRowBG;
340 BayerRow1 = BayerRowGR;
341 break;
342 case FOURCC_GBRG:
343 BayerRow0 = BayerRowGB;
344 BayerRow1 = BayerRowRG;
345 break;
346 case FOURCC_GRBG:
347 BayerRow0 = BayerRowGR;
348 BayerRow1 = BayerRowBG;
349 break;
350 case FOURCC_RGGB:
351 BayerRow0 = BayerRowRG;
352 BayerRow1 = BayerRowGB;
353 break;
354 default:
355 return -1; // Bad FourCC
356 }
358 // Allocate 2 rows of ARGB.
359 const int kRowSize = (width * 4 + 15) & ~15;
360 align_buffer_64(row, kRowSize * 2);
361 for (int y = 0; y < height - 1; y += 2) {
362 BayerRow0(src_bayer, src_stride_bayer, row, width);
363 BayerRow1(src_bayer + src_stride_bayer, -src_stride_bayer,
364 row + kRowSize, width);
365 ARGBToUVRow(row, kRowSize, dst_u, dst_v, width);
366 ARGBToYRow(row, dst_y, width);
367 ARGBToYRow(row + kRowSize, dst_y + dst_stride_y, width);
368 src_bayer += src_stride_bayer * 2;
369 dst_y += dst_stride_y * 2;
370 dst_u += dst_stride_u;
371 dst_v += dst_stride_v;
372 }
373 if (height & 1) {
374 BayerRow0(src_bayer, src_stride_bayer, row, width);
375 ARGBToUVRow(row, 0, dst_u, dst_v, width);
376 ARGBToYRow(row, dst_y, width);
377 }
378 free_aligned_buffer_64(row);
379 return 0;
380 }
382 // Convert I420 to Bayer.
383 LIBYUV_API
384 int I420ToBayer(const uint8* src_y, int src_stride_y,
385 const uint8* src_u, int src_stride_u,
386 const uint8* src_v, int src_stride_v,
387 uint8* dst_bayer, int dst_stride_bayer,
388 int width, int height,
389 uint32 dst_fourcc_bayer) {
390 // Negative height means invert the image.
391 if (height < 0) {
392 height = -height;
393 int halfheight = (height + 1) >> 1;
394 src_y = src_y + (height - 1) * src_stride_y;
395 src_u = src_u + (halfheight - 1) * src_stride_u;
396 src_v = src_v + (halfheight - 1) * src_stride_v;
397 src_stride_y = -src_stride_y;
398 src_stride_u = -src_stride_u;
399 src_stride_v = -src_stride_v;
400 }
401 void (*I422ToARGBRow)(const uint8* y_buf,
402 const uint8* u_buf,
403 const uint8* v_buf,
404 uint8* rgb_buf,
405 int width) = I422ToARGBRow_C;
406 #if defined(HAS_I422TOARGBROW_SSSE3)
407 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) {
408 I422ToARGBRow = I422ToARGBRow_Any_SSSE3;
409 if (IS_ALIGNED(width, 8)) {
410 I422ToARGBRow = I422ToARGBRow_SSSE3;
411 }
412 }
413 #endif
414 #if defined(HAS_I422TOARGBROW_AVX2)
415 if (TestCpuFlag(kCpuHasAVX2) && width >= 16) {
416 I422ToARGBRow = I422ToARGBRow_Any_AVX2;
417 if (IS_ALIGNED(width, 16)) {
418 I422ToARGBRow = I422ToARGBRow_AVX2;
419 }
420 }
421 #endif
422 #if defined(HAS_I422TOARGBROW_NEON)
423 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
424 I422ToARGBRow = I422ToARGBRow_Any_NEON;
425 if (IS_ALIGNED(width, 8)) {
426 I422ToARGBRow = I422ToARGBRow_NEON;
427 }
428 }
429 #endif
430 #if defined(HAS_I422TOARGBROW_MIPS_DSPR2)
431 if (TestCpuFlag(kCpuHasMIPS_DSPR2) && IS_ALIGNED(width, 4) &&
432 IS_ALIGNED(src_y, 4) && IS_ALIGNED(src_stride_y, 4) &&
433 IS_ALIGNED(src_u, 2) && IS_ALIGNED(src_stride_u, 2) &&
434 IS_ALIGNED(src_v, 2) && IS_ALIGNED(src_stride_v, 2)) {
435 I422ToARGBRow = I422ToARGBRow_MIPS_DSPR2;
436 }
437 #endif
439 void (*ARGBToBayerRow)(const uint8* src_argb, uint8* dst_bayer,
440 uint32 selector, int pix) = ARGBToBayerRow_C;
441 #if defined(HAS_ARGBTOBAYERROW_SSSE3)
442 if (TestCpuFlag(kCpuHasSSSE3) && width >= 8) {
443 ARGBToBayerRow = ARGBToBayerRow_Any_SSSE3;
444 if (IS_ALIGNED(width, 8)) {
445 ARGBToBayerRow = ARGBToBayerRow_SSSE3;
446 }
447 }
448 #elif defined(HAS_ARGBTOBAYERROW_NEON)
449 if (TestCpuFlag(kCpuHasNEON) && width >= 8) {
450 ARGBToBayerRow = ARGBToBayerRow_Any_NEON;
451 if (IS_ALIGNED(width, 8)) {
452 ARGBToBayerRow = ARGBToBayerRow_NEON;
453 }
454 }
455 #endif
457 const int blue_index = 0; // Offsets for ARGB format
458 const int green_index = 1;
459 const int red_index = 2;
460 uint32 index_map[2];
461 if (MakeSelectors(blue_index, green_index, red_index,
462 dst_fourcc_bayer, index_map)) {
463 return -1; // Bad FourCC
464 }
465 // Allocate a row of ARGB.
466 align_buffer_64(row, width * 4);
467 for (int y = 0; y < height; ++y) {
468 I422ToARGBRow(src_y, src_u, src_v, row, width);
469 ARGBToBayerRow(row, dst_bayer, index_map[y & 1], width);
470 dst_bayer += dst_stride_bayer;
471 src_y += src_stride_y;
472 if (y & 1) {
473 src_u += src_stride_u;
474 src_v += src_stride_v;
475 }
476 }
477 free_aligned_buffer_64(row);
478 return 0;
479 }
481 #define MAKEBAYERFOURCC(BAYER) \
482 LIBYUV_API \
483 int Bayer##BAYER##ToI420(const uint8* src_bayer, int src_stride_bayer, \
484 uint8* dst_y, int dst_stride_y, \
485 uint8* dst_u, int dst_stride_u, \
486 uint8* dst_v, int dst_stride_v, \
487 int width, int height) { \
488 return BayerToI420(src_bayer, src_stride_bayer, \
489 dst_y, dst_stride_y, \
490 dst_u, dst_stride_u, \
491 dst_v, dst_stride_v, \
492 width, height, \
493 FOURCC_##BAYER); \
494 } \
495 \
496 LIBYUV_API \
497 int I420ToBayer##BAYER(const uint8* src_y, int src_stride_y, \
498 const uint8* src_u, int src_stride_u, \
499 const uint8* src_v, int src_stride_v, \
500 uint8* dst_bayer, int dst_stride_bayer, \
501 int width, int height) { \
502 return I420ToBayer(src_y, src_stride_y, \
503 src_u, src_stride_u, \
504 src_v, src_stride_v, \
505 dst_bayer, dst_stride_bayer, \
506 width, height, \
507 FOURCC_##BAYER); \
508 } \
509 \
510 LIBYUV_API \
511 int ARGBToBayer##BAYER(const uint8* src_argb, int src_stride_argb, \
512 uint8* dst_bayer, int dst_stride_bayer, \
513 int width, int height) { \
514 return ARGBToBayer(src_argb, src_stride_argb, \
515 dst_bayer, dst_stride_bayer, \
516 width, height, \
517 FOURCC_##BAYER); \
518 } \
519 \
520 LIBYUV_API \
521 int Bayer##BAYER##ToARGB(const uint8* src_bayer, int src_stride_bayer, \
522 uint8* dst_argb, int dst_stride_argb, \
523 int width, int height) { \
524 return BayerToARGB(src_bayer, src_stride_bayer, \
525 dst_argb, dst_stride_argb, \
526 width, height, \
527 FOURCC_##BAYER); \
528 }
530 MAKEBAYERFOURCC(BGGR)
531 MAKEBAYERFOURCC(GBRG)
532 MAKEBAYERFOURCC(GRBG)
533 MAKEBAYERFOURCC(RGGB)
535 #ifdef __cplusplus
536 } // extern "C"
537 } // namespace libyuv
538 #endif
