?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bug 588735 - Mirror glass caption buttons for rtl windows. r=roc, a=blocking-betaN.
[mozilla-central.git] / gfx / ycbcr / convert.patch
blob75f38bba739ebcd2f908d98c06495ce5a631b947
1 diff --git b/gfx/ycbcr/yuv_convert.cpp a/gfx/ycbcr/yuv_convert.cpp
2 index c73dfe4..c291d5c 100644
3 --- b/gfx/ycbcr/yuv_convert.cpp
4 +++ a/gfx/ycbcr/yuv_convert.cpp
5 @@ -10,67 +10,80 @@
6 // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
7 //
8 // YV12 is a full plane of Y and a half height, half width chroma planes
9 // YV16 is a full plane of Y and a full height, half width chroma planes
10 //
11 // ARGB pixel format is output, which on little endian is stored as BGRA.
12 // The alpha is set to 255, allowing the application to use RGBA or RGB32.
13
14 -#include "media/base/yuv_convert.h"
15 +#include "yuv_convert.h"
16
17 // Header for low level row functions.
18 -#include "media/base/yuv_row.h"
19 +#include "yuv_row.h"
20 +#include "mozilla/SSE.h"
21
22 -namespace media {
23 +namespace mozilla {
24 +
25 +namespace gfx {
26
27 // Convert a frame of YUV to 32 bit ARGB.
28 -void ConvertYUVToRGB32(const uint8* y_buf,
29 - const uint8* u_buf,
30 - const uint8* v_buf,
31 - uint8* rgb_buf,
32 - int width,
33 - int height,
34 - int y_pitch,
35 - int uv_pitch,
36 - int rgb_pitch,
37 - YUVType yuv_type) {
38 +void ConvertYCbCrToRGB32(const uint8* y_buf,
39 + const uint8* u_buf,
40 + const uint8* v_buf,
41 + uint8* rgb_buf,
42 + int width,
43 + int height,
44 + int y_pitch,
45 + int uv_pitch,
46 + int rgb_pitch,
47 + YUVType yuv_type) {
48 unsigned int y_shift = yuv_type;
49 + bool has_mmx = supports_mmx();
50 for (int y = 0; y < height; ++y) {
51 uint8* rgb_row = rgb_buf + y * rgb_pitch;
52 const uint8* y_ptr = y_buf + y * y_pitch;
53 const uint8* u_ptr = u_buf + (y >> y_shift) * uv_pitch;
54 const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch;
55
56 - FastConvertYUVToRGB32Row(y_ptr,
57 - u_ptr,
58 - v_ptr,
59 - rgb_row,
60 - width);
61 + if (has_mmx)
62 + FastConvertYUVToRGB32Row(y_ptr,
63 + u_ptr,
64 + v_ptr,
65 + rgb_row,
66 + width);
67 + else
68 + FastConvertYUVToRGB32Row_C(y_ptr,
69 + u_ptr,
70 + v_ptr,
71 + rgb_row,
72 + width);
73 }
74
75 // MMX used for FastConvertYUVToRGB32Row requires emms instruction.
76 - EMMS();
77 + if (has_mmx)
78 + EMMS();
79 }
80
81 // Scale a frame of YUV to 32 bit ARGB.
82 -void ScaleYUVToRGB32(const uint8* y_buf,
83 - const uint8* u_buf,
84 - const uint8* v_buf,
85 - uint8* rgb_buf,
86 - int width,
87 - int height,
88 - int scaled_width,
89 - int scaled_height,
90 - int y_pitch,
91 - int uv_pitch,
92 - int rgb_pitch,
93 - YUVType yuv_type,
94 - Rotate view_rotate) {
95 +void ScaleYCbCrToRGB32(const uint8* y_buf,
96 + const uint8* u_buf,
97 + const uint8* v_buf,
98 + uint8* rgb_buf,
99 + int width,
100 + int height,
101 + int scaled_width,
102 + int scaled_height,
103 + int y_pitch,
104 + int uv_pitch,
105 + int rgb_pitch,
106 + YUVType yuv_type,
107 + Rotate view_rotate) {
108 unsigned int y_shift = yuv_type;
109 + bool has_mmx = supports_mmx();
110 // Diagram showing origin and direction of source sampling.
111 // ->0 4<-
112 // 7 3
113 //
114 // 6 5
115 // ->1 2<-
116 // Rotations that start at right side of image.
117 if ((view_rotate == ROTATE_180) ||
118 @@ -126,42 +139,57 @@ void ScaleYUVToRGB32(const uint8* y_buf,
119
120 for (int y = 0; y < scaled_height; ++y) {
121 uint8* dest_pixel = rgb_buf + y * rgb_pitch;
122 int scaled_y = (y * height / scaled_height);
123 const uint8* y_ptr = y_buf + scaled_y * y_pitch;
124 const uint8* u_ptr = u_buf + (scaled_y >> y_shift) * uv_pitch;
125 const uint8* v_ptr = v_buf + (scaled_y >> y_shift) * uv_pitch;
126
127 -#if USE_MMX && defined(_MSC_VER)
128 +#if defined(_MSC_VER)
129 if (scaled_width == (width * 2)) {
130 DoubleYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
131 dest_pixel, scaled_width);
132 } else if ((scaled_dx & 15) == 0) { // Scaling by integer scale factor.
133 if (scaled_dx_uv == scaled_dx) { // Not rotated.
134 if (scaled_dx == 16) { // Not scaled
135 - FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
136 - dest_pixel, scaled_width);
137 + if (has_mmx)
138 + FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
139 + dest_pixel, scaled_width);
140 + else
141 + FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr,
142 + dest_pixel, scaled_width);
143 } else { // Simple scale down. ie half
144 ConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
145 dest_pixel, scaled_width, scaled_dx >> 4);
146 }
147 } else {
148 RotateConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
149 dest_pixel, scaled_width,
150 scaled_dx >> 4, scaled_dx_uv >> 4);
151 }
152 #else
153 if (scaled_dx == 16) { // Not scaled
154 - FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
155 - dest_pixel, scaled_width);
156 + if (has_mmx)
157 + FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
158 + dest_pixel, scaled_width);
159 + else
160 + FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr,
161 + dest_pixel, scaled_width);
162 #endif
163 } else {
164 - ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
165 - dest_pixel, scaled_width, scaled_dx);
166 - }
167 + if (has_mmx)
168 + ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
169 + dest_pixel, scaled_width, scaled_dx);
170 + else
171 + ScaleYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr,
172 + dest_pixel, scaled_width, scaled_dx);
173 +
174 + }
175 }
176
177 // MMX used for FastConvertYUVToRGB32Row requires emms instruction.
178 - EMMS();
179 + if (has_mmx)
180 + EMMS();
181 }
182
183 -} // namespace media
184 +} // namespace gfx
185 +} // namespace mozilla
186 diff --git b/gfx/ycbcr/yuv_convert.h a/gfx/ycbcr/yuv_convert.h
187 index a757070..9d148a6 100644
188 --- b/gfx/ycbcr/yuv_convert.h
189 +++ a/gfx/ycbcr/yuv_convert.h
190 @@ -1,63 +1,66 @@
191 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
192 // Use of this source code is governed by a BSD-style license that can be
193 // found in the LICENSE file.
194
195 #ifndef MEDIA_BASE_YUV_CONVERT_H_
196 #define MEDIA_BASE_YUV_CONVERT_H_
197
198 -#include "base/basictypes.h"
199 +#include "chromium_types.h"
200
201 -namespace media {
202 +namespace mozilla {
203 +
204 +namespace gfx {
205
206 // Type of YUV surface.
207 // The value of these enums matter as they are used to shift vertical indices.
208 enum YUVType {
209 YV16 = 0, // YV16 is half width and full height chroma channels.
210 - YV12 = 1, // YV12 is half width and half height chroma channels.
211 + YV12 = 1 // YV12 is half width and half height chroma channels.
212 };
213
214 // Mirror means flip the image horizontally, as in looking in a mirror.
215 // Rotate happens after mirroring.
216 enum Rotate {
217 ROTATE_0, // Rotation off.
218 ROTATE_90, // Rotate clockwise.
219 ROTATE_180, // Rotate upside down.
220 ROTATE_270, // Rotate counter clockwise.
221 MIRROR_ROTATE_0, // Mirror horizontally.
222 MIRROR_ROTATE_90, // Mirror then Rotate clockwise.
223 MIRROR_ROTATE_180, // Mirror vertically.
224 - MIRROR_ROTATE_270, // Transpose.
225 + MIRROR_ROTATE_270 // Transpose.
226 };
227
228 // Convert a frame of YUV to 32 bit ARGB.
229 // Pass in YV16/YV12 depending on source format
230 -void ConvertYUVToRGB32(const uint8* yplane,
231 +void ConvertYCbCrToRGB32(const uint8* yplane,
232 + const uint8* uplane,
233 + const uint8* vplane,
234 + uint8* rgbframe,
235 + int frame_width,
236 + int frame_height,
237 + int ystride,
238 + int uvstride,
239 + int rgbstride,
240 + YUVType yuv_type);
241 +
242 +// Scale a frame of YUV to 32 bit ARGB.
243 +// Supports rotation and mirroring.
244 +void ScaleYCbCrToRGB32(const uint8* yplane,
245 const uint8* uplane,
246 const uint8* vplane,
247 uint8* rgbframe,
248 int frame_width,
249 int frame_height,
250 + int scaled_width,
251 + int scaled_height,
252 int ystride,
253 int uvstride,
254 int rgbstride,
255 - YUVType yuv_type);
256 + YUVType yuv_type,
257 + Rotate view_rotate);
258
259 -// Scale a frame of YUV to 32 bit ARGB.
260 -// Supports rotation and mirroring.
261 -void ScaleYUVToRGB32(const uint8* yplane,
262 - const uint8* uplane,
263 - const uint8* vplane,
264 - uint8* rgbframe,
265 - int frame_width,
266 - int frame_height,
267 - int scaled_width,
268 - int scaled_height,
269 - int ystride,
270 - int uvstride,
271 - int rgbstride,
272 - YUVType yuv_type,
273 - Rotate view_rotate);
274 -
275 -} // namespace media
276 +} // namespace gfx
277 +} // namespace mozilla
278
279 #endif // MEDIA_BASE_YUV_CONVERT_H_
280 diff --git b/gfx/ycbcr/yuv_row.h a/gfx/ycbcr/yuv_row.h
281 index ac5c6fd..98efca6 100644
282 --- b/gfx/ycbcr/yuv_row.h
283 +++ a/gfx/ycbcr/yuv_row.h
284 @@ -5,27 +5,34 @@
285 // yuv_row internal functions to handle YUV conversion and scaling to RGB.
286 // These functions are used from both yuv_convert.cc and yuv_scale.cc.
287
288 // TODO(fbarchard): Write function that can handle rotation and scaling.
289
290 #ifndef MEDIA_BASE_YUV_ROW_H_
291 #define MEDIA_BASE_YUV_ROW_H_
292
293 -#include "base/basictypes.h"
294 +#include "chromium_types.h"
295
296 extern "C" {
297 // Can only do 1x.
298 // This is the second fastest of the scalers.
299 void FastConvertYUVToRGB32Row(const uint8* y_buf,
300 const uint8* u_buf,
301 const uint8* v_buf,
302 uint8* rgb_buf,
303 int width);
304
305 +void FastConvertYUVToRGB32Row_C(const uint8* y_buf,
306 + const uint8* u_buf,
307 + const uint8* v_buf,
308 + uint8* rgb_buf,
309 + int width);
310 +
311 +
312 // Can do 1x, half size or any scale down by an integer amount.
313 // Step can be negative (mirroring, rotate 180).
314 // This is the third fastest of the scalers.
315 void ConvertYUVToRGB32Row(const uint8* y_buf,
316 const uint8* u_buf,
317 const uint8* v_buf,
318 uint8* rgb_buf,
319 int width,
320 @@ -55,29 +62,28 @@ void DoubleYUVToRGB32Row(const uint8* y_buf,
321 // Chroma is under sampled every 2 pixels for performance.
322 // This is the slowest of the scalers.
323 void ScaleYUVToRGB32Row(const uint8* y_buf,
324 const uint8* u_buf,
325 const uint8* v_buf,
326 uint8* rgb_buf,
327 int width,
328 int scaled_dx);
329 -} // extern "C"
330
331 -#if !defined(USE_MMX)
332 -// Windows, Mac and Linux use MMX
333 -#if defined(ARCH_CPU_X86) || (defined(ARCH_CPU_X86_64) && defined(OS_LINUX))
334 -#define USE_MMX 1
335 -#else
336 -#define USE_MMX 0
337 -#endif
338 -#endif
339 +void ScaleYUVToRGB32Row_C(const uint8* y_buf,
340 + const uint8* u_buf,
341 + const uint8* v_buf,
342 + uint8* rgb_buf,
343 + int width,
344 + int scaled_dx);
345 +
346 +} // extern "C"
347
348 // x64 uses MMX2 (SSE) so emms is not required.
349 -#if USE_MMX && !defined(ARCH_CPU_X86_64)
350 +#if !defined(ARCH_CPU_X86_64)
351 #if defined(_MSC_VER)
352 #define EMMS() __asm emms
353 #else
354 #define EMMS() asm("emms")
355 #endif
356 #else
357 #define EMMS()
358 #endif
359 diff --git b/gfx/ycbcr/yuv_row_c.cpp a/gfx/ycbcr/yuv_row_c.cpp
360 index 4a20777..a81416c 100644
361 --- b/gfx/ycbcr/yuv_row_c.cpp
362 +++ a/gfx/ycbcr/yuv_row_c.cpp
363 @@ -1,522 +1,20 @@
364 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
365 // Use of this source code is governed by a BSD-style license that can be
366 // found in the LICENSE file.
367
368 -#include "media/base/yuv_row.h"
369 +#include "yuv_row.h"
370
371 -#ifdef _DEBUG
372 -#include "base/logging.h"
373 -#else
374 #define DCHECK(a)
375 -#endif
376
377 // TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac.
378 // TODO(fbarchard): Do 64 bit version.
379
380 extern "C" {
381 -#if USE_MMX
382 -
383 -#define RGBY(i) { \
384 - static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
385 - static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
386 - static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
387 - 0 \
388 -}
389 -
390 -#define RGBU(i) { \
391 - static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \
392 - static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \
393 - 0, \
394 - static_cast<int16>(256 * 64 - 1) \
395 -}
396 -
397 -#define RGBV(i) { \
398 - 0, \
399 - static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \
400 - static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \
401 - 0 \
402 -}
403 -
404 -#define MMX_ALIGNED(var) var __attribute__((aligned(16)))
405 -
406 -
407 -MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = {
408 - RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03),
409 - RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07),
410 - RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B),
411 - RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F),
412 - RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13),
413 - RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17),
414 - RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B),
415 - RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F),
416 - RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23),
417 - RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27),
418 - RGBY(0x28), RGBY(0x29), RGBY(0x2A), RGBY(0x2B),
419 - RGBY(0x2C), RGBY(0x2D), RGBY(0x2E), RGBY(0x2F),
420 - RGBY(0x30), RGBY(0x31), RGBY(0x32), RGBY(0x33),
421 - RGBY(0x34), RGBY(0x35), RGBY(0x36), RGBY(0x37),
422 - RGBY(0x38), RGBY(0x39), RGBY(0x3A), RGBY(0x3B),
423 - RGBY(0x3C), RGBY(0x3D), RGBY(0x3E), RGBY(0x3F),
424 - RGBY(0x40), RGBY(0x41), RGBY(0x42), RGBY(0x43),
425 - RGBY(0x44), RGBY(0x45), RGBY(0x46), RGBY(0x47),
426 - RGBY(0x48), RGBY(0x49), RGBY(0x4A), RGBY(0x4B),
427 - RGBY(0x4C), RGBY(0x4D), RGBY(0x4E), RGBY(0x4F),
428 - RGBY(0x50), RGBY(0x51), RGBY(0x52), RGBY(0x53),
429 - RGBY(0x54), RGBY(0x55), RGBY(0x56), RGBY(0x57),
430 - RGBY(0x58), RGBY(0x59), RGBY(0x5A), RGBY(0x5B),
431 - RGBY(0x5C), RGBY(0x5D), RGBY(0x5E), RGBY(0x5F),
432 - RGBY(0x60), RGBY(0x61), RGBY(0x62), RGBY(0x63),
433 - RGBY(0x64), RGBY(0x65), RGBY(0x66), RGBY(0x67),
434 - RGBY(0x68), RGBY(0x69), RGBY(0x6A), RGBY(0x6B),
435 - RGBY(0x6C), RGBY(0x6D), RGBY(0x6E), RGBY(0x6F),
436 - RGBY(0x70), RGBY(0x71), RGBY(0x72), RGBY(0x73),
437 - RGBY(0x74), RGBY(0x75), RGBY(0x76), RGBY(0x77),
438 - RGBY(0x78), RGBY(0x79), RGBY(0x7A), RGBY(0x7B),
439 - RGBY(0x7C), RGBY(0x7D), RGBY(0x7E), RGBY(0x7F),
440 - RGBY(0x80), RGBY(0x81), RGBY(0x82), RGBY(0x83),
441 - RGBY(0x84), RGBY(0x85), RGBY(0x86), RGBY(0x87),
442 - RGBY(0x88), RGBY(0x89), RGBY(0x8A), RGBY(0x8B),
443 - RGBY(0x8C), RGBY(0x8D), RGBY(0x8E), RGBY(0x8F),
444 - RGBY(0x90), RGBY(0x91), RGBY(0x92), RGBY(0x93),
445 - RGBY(0x94), RGBY(0x95), RGBY(0x96), RGBY(0x97),
446 - RGBY(0x98), RGBY(0x99), RGBY(0x9A), RGBY(0x9B),
447 - RGBY(0x9C), RGBY(0x9D), RGBY(0x9E), RGBY(0x9F),
448 - RGBY(0xA0), RGBY(0xA1), RGBY(0xA2), RGBY(0xA3),
449 - RGBY(0xA4), RGBY(0xA5), RGBY(0xA6), RGBY(0xA7),
450 - RGBY(0xA8), RGBY(0xA9), RGBY(0xAA), RGBY(0xAB),
451 - RGBY(0xAC), RGBY(0xAD), RGBY(0xAE), RGBY(0xAF),
452 - RGBY(0xB0), RGBY(0xB1), RGBY(0xB2), RGBY(0xB3),
453 - RGBY(0xB4), RGBY(0xB5), RGBY(0xB6), RGBY(0xB7),
454 - RGBY(0xB8), RGBY(0xB9), RGBY(0xBA), RGBY(0xBB),
455 - RGBY(0xBC), RGBY(0xBD), RGBY(0xBE), RGBY(0xBF),
456 - RGBY(0xC0), RGBY(0xC1), RGBY(0xC2), RGBY(0xC3),
457 - RGBY(0xC4), RGBY(0xC5), RGBY(0xC6), RGBY(0xC7),
458 - RGBY(0xC8), RGBY(0xC9), RGBY(0xCA), RGBY(0xCB),
459 - RGBY(0xCC), RGBY(0xCD), RGBY(0xCE), RGBY(0xCF),
460 - RGBY(0xD0), RGBY(0xD1), RGBY(0xD2), RGBY(0xD3),
461 - RGBY(0xD4), RGBY(0xD5), RGBY(0xD6), RGBY(0xD7),
462 - RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB),
463 - RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF),
464 - RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3),
465 - RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7),
466 - RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB),
467 - RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF),
468 - RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3),
469 - RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7),
470 - RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB),
471 - RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF),
472 -
473 - // Chroma U table.
474 - RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03),
475 - RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07),
476 - RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B),
477 - RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F),
478 - RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13),
479 - RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17),
480 - RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B),
481 - RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F),
482 - RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23),
483 - RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27),
484 - RGBU(0x28), RGBU(0x29), RGBU(0x2A), RGBU(0x2B),
485 - RGBU(0x2C), RGBU(0x2D), RGBU(0x2E), RGBU(0x2F),
486 - RGBU(0x30), RGBU(0x31), RGBU(0x32), RGBU(0x33),
487 - RGBU(0x34), RGBU(0x35), RGBU(0x36), RGBU(0x37),
488 - RGBU(0x38), RGBU(0x39), RGBU(0x3A), RGBU(0x3B),
489 - RGBU(0x3C), RGBU(0x3D), RGBU(0x3E), RGBU(0x3F),
490 - RGBU(0x40), RGBU(0x41), RGBU(0x42), RGBU(0x43),
491 - RGBU(0x44), RGBU(0x45), RGBU(0x46), RGBU(0x47),
492 - RGBU(0x48), RGBU(0x49), RGBU(0x4A), RGBU(0x4B),
493 - RGBU(0x4C), RGBU(0x4D), RGBU(0x4E), RGBU(0x4F),
494 - RGBU(0x50), RGBU(0x51), RGBU(0x52), RGBU(0x53),
495 - RGBU(0x54), RGBU(0x55), RGBU(0x56), RGBU(0x57),
496 - RGBU(0x58), RGBU(0x59), RGBU(0x5A), RGBU(0x5B),
497 - RGBU(0x5C), RGBU(0x5D), RGBU(0x5E), RGBU(0x5F),
498 - RGBU(0x60), RGBU(0x61), RGBU(0x62), RGBU(0x63),
499 - RGBU(0x64), RGBU(0x65), RGBU(0x66), RGBU(0x67),
500 - RGBU(0x68), RGBU(0x69), RGBU(0x6A), RGBU(0x6B),
501 - RGBU(0x6C), RGBU(0x6D), RGBU(0x6E), RGBU(0x6F),
502 - RGBU(0x70), RGBU(0x71), RGBU(0x72), RGBU(0x73),
503 - RGBU(0x74), RGBU(0x75), RGBU(0x76), RGBU(0x77),
504 - RGBU(0x78), RGBU(0x79), RGBU(0x7A), RGBU(0x7B),
505 - RGBU(0x7C), RGBU(0x7D), RGBU(0x7E), RGBU(0x7F),
506 - RGBU(0x80), RGBU(0x81), RGBU(0x82), RGBU(0x83),
507 - RGBU(0x84), RGBU(0x85), RGBU(0x86), RGBU(0x87),
508 - RGBU(0x88), RGBU(0x89), RGBU(0x8A), RGBU(0x8B),
509 - RGBU(0x8C), RGBU(0x8D), RGBU(0x8E), RGBU(0x8F),
510 - RGBU(0x90), RGBU(0x91), RGBU(0x92), RGBU(0x93),
511 - RGBU(0x94), RGBU(0x95), RGBU(0x96), RGBU(0x97),
512 - RGBU(0x98), RGBU(0x99), RGBU(0x9A), RGBU(0x9B),
513 - RGBU(0x9C), RGBU(0x9D), RGBU(0x9E), RGBU(0x9F),
514 - RGBU(0xA0), RGBU(0xA1), RGBU(0xA2), RGBU(0xA3),
515 - RGBU(0xA4), RGBU(0xA5), RGBU(0xA6), RGBU(0xA7),
516 - RGBU(0xA8), RGBU(0xA9), RGBU(0xAA), RGBU(0xAB),
517 - RGBU(0xAC), RGBU(0xAD), RGBU(0xAE), RGBU(0xAF),
518 - RGBU(0xB0), RGBU(0xB1), RGBU(0xB2), RGBU(0xB3),
519 - RGBU(0xB4), RGBU(0xB5), RGBU(0xB6), RGBU(0xB7),
520 - RGBU(0xB8), RGBU(0xB9), RGBU(0xBA), RGBU(0xBB),
521 - RGBU(0xBC), RGBU(0xBD), RGBU(0xBE), RGBU(0xBF),
522 - RGBU(0xC0), RGBU(0xC1), RGBU(0xC2), RGBU(0xC3),
523 - RGBU(0xC4), RGBU(0xC5), RGBU(0xC6), RGBU(0xC7),
524 - RGBU(0xC8), RGBU(0xC9), RGBU(0xCA), RGBU(0xCB),
525 - RGBU(0xCC), RGBU(0xCD), RGBU(0xCE), RGBU(0xCF),
526 - RGBU(0xD0), RGBU(0xD1), RGBU(0xD2), RGBU(0xD3),
527 - RGBU(0xD4), RGBU(0xD5), RGBU(0xD6), RGBU(0xD7),
528 - RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB),
529 - RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF),
530 - RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3),
531 - RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7),
532 - RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB),
533 - RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF),
534 - RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3),
535 - RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7),
536 - RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB),
537 - RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF),
538 -
539 - // Chroma V table.
540 - RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03),
541 - RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07),
542 - RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B),
543 - RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F),
544 - RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13),
545 - RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17),
546 - RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B),
547 - RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F),
548 - RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23),
549 - RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27),
550 - RGBV(0x28), RGBV(0x29), RGBV(0x2A), RGBV(0x2B),
551 - RGBV(0x2C), RGBV(0x2D), RGBV(0x2E), RGBV(0x2F),
552 - RGBV(0x30), RGBV(0x31), RGBV(0x32), RGBV(0x33),
553 - RGBV(0x34), RGBV(0x35), RGBV(0x36), RGBV(0x37),
554 - RGBV(0x38), RGBV(0x39), RGBV(0x3A), RGBV(0x3B),
555 - RGBV(0x3C), RGBV(0x3D), RGBV(0x3E), RGBV(0x3F),
556 - RGBV(0x40), RGBV(0x41), RGBV(0x42), RGBV(0x43),
557 - RGBV(0x44), RGBV(0x45), RGBV(0x46), RGBV(0x47),
558 - RGBV(0x48), RGBV(0x49), RGBV(0x4A), RGBV(0x4B),
559 - RGBV(0x4C), RGBV(0x4D), RGBV(0x4E), RGBV(0x4F),
560 - RGBV(0x50), RGBV(0x51), RGBV(0x52), RGBV(0x53),
561 - RGBV(0x54), RGBV(0x55), RGBV(0x56), RGBV(0x57),
562 - RGBV(0x58), RGBV(0x59), RGBV(0x5A), RGBV(0x5B),
563 - RGBV(0x5C), RGBV(0x5D), RGBV(0x5E), RGBV(0x5F),
564 - RGBV(0x60), RGBV(0x61), RGBV(0x62), RGBV(0x63),
565 - RGBV(0x64), RGBV(0x65), RGBV(0x66), RGBV(0x67),
566 - RGBV(0x68), RGBV(0x69), RGBV(0x6A), RGBV(0x6B),
567 - RGBV(0x6C), RGBV(0x6D), RGBV(0x6E), RGBV(0x6F),
568 - RGBV(0x70), RGBV(0x71), RGBV(0x72), RGBV(0x73),
569 - RGBV(0x74), RGBV(0x75), RGBV(0x76), RGBV(0x77),
570 - RGBV(0x78), RGBV(0x79), RGBV(0x7A), RGBV(0x7B),
571 - RGBV(0x7C), RGBV(0x7D), RGBV(0x7E), RGBV(0x7F),
572 - RGBV(0x80), RGBV(0x81), RGBV(0x82), RGBV(0x83),
573 - RGBV(0x84), RGBV(0x85), RGBV(0x86), RGBV(0x87),
574 - RGBV(0x88), RGBV(0x89), RGBV(0x8A), RGBV(0x8B),
575 - RGBV(0x8C), RGBV(0x8D), RGBV(0x8E), RGBV(0x8F),
576 - RGBV(0x90), RGBV(0x91), RGBV(0x92), RGBV(0x93),
577 - RGBV(0x94), RGBV(0x95), RGBV(0x96), RGBV(0x97),
578 - RGBV(0x98), RGBV(0x99), RGBV(0x9A), RGBV(0x9B),
579 - RGBV(0x9C), RGBV(0x9D), RGBV(0x9E), RGBV(0x9F),
580 - RGBV(0xA0), RGBV(0xA1), RGBV(0xA2), RGBV(0xA3),
581 - RGBV(0xA4), RGBV(0xA5), RGBV(0xA6), RGBV(0xA7),
582 - RGBV(0xA8), RGBV(0xA9), RGBV(0xAA), RGBV(0xAB),
583 - RGBV(0xAC), RGBV(0xAD), RGBV(0xAE), RGBV(0xAF),
584 - RGBV(0xB0), RGBV(0xB1), RGBV(0xB2), RGBV(0xB3),
585 - RGBV(0xB4), RGBV(0xB5), RGBV(0xB6), RGBV(0xB7),
586 - RGBV(0xB8), RGBV(0xB9), RGBV(0xBA), RGBV(0xBB),
587 - RGBV(0xBC), RGBV(0xBD), RGBV(0xBE), RGBV(0xBF),
588 - RGBV(0xC0), RGBV(0xC1), RGBV(0xC2), RGBV(0xC3),
589 - RGBV(0xC4), RGBV(0xC5), RGBV(0xC6), RGBV(0xC7),
590 - RGBV(0xC8), RGBV(0xC9), RGBV(0xCA), RGBV(0xCB),
591 - RGBV(0xCC), RGBV(0xCD), RGBV(0xCE), RGBV(0xCF),
592 - RGBV(0xD0), RGBV(0xD1), RGBV(0xD2), RGBV(0xD3),
593 - RGBV(0xD4), RGBV(0xD5), RGBV(0xD6), RGBV(0xD7),
594 - RGBV(0xD8), RGBV(0xD9), RGBV(0xDA), RGBV(0xDB),
595 - RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF),
596 - RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3),
597 - RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7),
598 - RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB),
599 - RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF),
600 - RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3),
601 - RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7),
602 - RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB),
603 - RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF),
604 -};
605 -
606 -#undef RGBY
607 -#undef RGBU
608 -#undef RGBV
609 -#undef MMX_ALIGNED
610 -
611 -#if defined(ARCH_CPU_X86_64)
612 -
613 -// AMD64 ABI uses register paremters.
614 -void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi
615 - const uint8* u_buf, // rsi
616 - const uint8* v_buf, // rdx
617 - uint8* rgb_buf, // rcx
618 - int width) { // r8
619 - asm(
620 - "jmp convertend\n"
621 -"convertloop:"
622 - "movzb (%1),%%r10\n"
623 - "add $0x1,%1\n"
624 - "movzb (%2),%%r11\n"
625 - "add $0x1,%2\n"
626 - "movq 2048(%5,%%r10,8),%%xmm0\n"
627 - "movzb (%0),%%r10\n"
628 - "movq 4096(%5,%%r11,8),%%xmm1\n"
629 - "movzb 0x1(%0),%%r11\n"
630 - "paddsw %%xmm1,%%xmm0\n"
631 - "movq (%5,%%r10,8),%%xmm2\n"
632 - "add $0x2,%0\n"
633 - "movq (%5,%%r11,8),%%xmm3\n"
634 - "paddsw %%xmm0,%%xmm2\n"
635 - "paddsw %%xmm0,%%xmm3\n"
636 - "shufps $0x44,%%xmm3,%%xmm2\n"
637 - "psraw $0x6,%%xmm2\n"
638 - "packuswb %%xmm2,%%xmm2\n"
639 - "movq %%xmm2,0x0(%3)\n"
640 - "add $0x8,%3\n"
641 -"convertend:"
642 - "sub $0x2,%4\n"
643 - "jns convertloop\n"
644 -
645 -"convertnext:"
646 - "add $0x1,%4\n"
647 - "js convertdone\n"
648 -
649 - "movzb (%1),%%r10\n"
650 - "movq 2048(%5,%%r10,8),%%xmm0\n"
651 - "movzb (%2),%%r10\n"
652 - "movq 4096(%5,%%r10,8),%%xmm1\n"
653 - "paddsw %%xmm1,%%xmm0\n"
654 - "movzb (%0),%%r10\n"
655 - "movq (%5,%%r10,8),%%xmm1\n"
656 - "paddsw %%xmm0,%%xmm1\n"
657 - "psraw $0x6,%%xmm1\n"
658 - "packuswb %%xmm1,%%xmm1\n"
659 - "movd %%xmm1,0x0(%3)\n"
660 -"convertdone:"
661 - :
662 - : "r"(y_buf), // %0
663 - "r"(u_buf), // %1
664 - "r"(v_buf), // %2
665 - "r"(rgb_buf), // %3
666 - "r"(width), // %4
667 - "r" (kCoefficientsRgbY) // %5
668 - : "memory", "r10", "r11", "xmm0", "xmm1", "xmm2", "xmm3"
669 -);
670 -}
671 -
672 -void ScaleYUVToRGB32Row(const uint8* y_buf, // rdi
673 - const uint8* u_buf, // rsi
674 - const uint8* v_buf, // rdx
675 - uint8* rgb_buf, // rcx
676 - int width, // r8
677 - int scaled_dx) { // r9
678 - asm(
679 - "xor %%r11,%%r11\n"
680 - "sub $0x2,%4\n"
681 - "js scalenext\n"
682 -
683 -"scaleloop:"
684 - "mov %%r11,%%r10\n"
685 - "sar $0x5,%%r10\n"
686 - "movzb (%1,%%r10,1),%%rax\n"
687 - "movq 2048(%5,%%rax,8),%%xmm0\n"
688 - "movzb (%2,%%r10,1),%%rax\n"
689 - "movq 4096(%5,%%rax,8),%%xmm1\n"
690 - "lea (%%r11,%6),%%r10\n"
691 - "sar $0x4,%%r11\n"
692 - "movzb (%0,%%r11,1),%%rax\n"
693 - "paddsw %%xmm1,%%xmm0\n"
694 - "movq (%5,%%rax,8),%%xmm1\n"
695 - "lea (%%r10,%6),%%r11\n"
696 - "sar $0x4,%%r10\n"
697 - "movzb (%0,%%r10,1),%%rax\n"
698 - "movq (%5,%%rax,8),%%xmm2\n"
699 - "paddsw %%xmm0,%%xmm1\n"
700 - "paddsw %%xmm0,%%xmm2\n"
701 - "shufps $0x44,%%xmm2,%%xmm1\n"
702 - "psraw $0x6,%%xmm1\n"
703 - "packuswb %%xmm1,%%xmm1\n"
704 - "movq %%xmm1,0x0(%3)\n"
705 - "add $0x8,%3\n"
706 - "sub $0x2,%4\n"
707 - "jns scaleloop\n"
708 -
709 -"scalenext:"
710 - "add $0x1,%4\n"
711 - "js scaledone\n"
712 -
713 - "mov %%r11,%%r10\n"
714 - "sar $0x5,%%r10\n"
715 - "movzb (%1,%%r10,1),%%rax\n"
716 - "movq 2048(%5,%%rax,8),%%xmm0\n"
717 - "movzb (%2,%%r10,1),%%rax\n"
718 - "movq 4096(%5,%%rax,8),%%xmm1\n"
719 - "paddsw %%xmm1,%%xmm0\n"
720 - "sar $0x4,%%r11\n"
721 - "movzb (%0,%%r11,1),%%rax\n"
722 - "movq (%5,%%rax,8),%%xmm1\n"
723 - "paddsw %%xmm0,%%xmm1\n"
724 - "psraw $0x6,%%xmm1\n"
725 - "packuswb %%xmm1,%%xmm1\n"
726 - "movd %%xmm1,0x0(%3)\n"
727 -
728 -"scaledone:"
729 - :
730 - : "r"(y_buf), // %0
731 - "r"(u_buf), // %1
732 - "r"(v_buf), // %2
733 - "r"(rgb_buf), // %3
734 - "r"(width), // %4
735 - "r" (kCoefficientsRgbY), // %5
736 - "r"(static_cast<long>(scaled_dx)) // %6
737 - : "memory", "r10", "r11", "rax", "xmm0", "xmm1", "xmm2"
738 -);
739 -}
740 -
741 -#else
742 -
743 -void FastConvertYUVToRGB32Row(const uint8* y_buf,
744 - const uint8* u_buf,
745 - const uint8* v_buf,
746 - uint8* rgb_buf,
747 - int width);
748 -
749 - asm(
750 - ".global FastConvertYUVToRGB32Row\n"
751 -"FastConvertYUVToRGB32Row:\n"
752 - "pusha\n"
753 - "mov 0x24(%esp),%edx\n"
754 - "mov 0x28(%esp),%edi\n"
755 - "mov 0x2c(%esp),%esi\n"
756 - "mov 0x30(%esp),%ebp\n"
757 - "mov 0x34(%esp),%ecx\n"
758 - "jmp convertend\n"
759 -
760 -"convertloop:"
761 - "movzbl (%edi),%eax\n"
762 - "add $0x1,%edi\n"
763 - "movzbl (%esi),%ebx\n"
764 - "add $0x1,%esi\n"
765 - "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
766 - "movzbl (%edx),%eax\n"
767 - "paddsw kCoefficientsRgbY+4096(,%ebx,8),%mm0\n"
768 - "movzbl 0x1(%edx),%ebx\n"
769 - "movq kCoefficientsRgbY(,%eax,8),%mm1\n"
770 - "add $0x2,%edx\n"
771 - "movq kCoefficientsRgbY(,%ebx,8),%mm2\n"
772 - "paddsw %mm0,%mm1\n"
773 - "paddsw %mm0,%mm2\n"
774 - "psraw $0x6,%mm1\n"
775 - "psraw $0x6,%mm2\n"
776 - "packuswb %mm2,%mm1\n"
777 - "movntq %mm1,0x0(%ebp)\n"
778 - "add $0x8,%ebp\n"
779 -"convertend:"
780 - "sub $0x2,%ecx\n"
781 - "jns convertloop\n"
782 -
783 - "and $0x1,%ecx\n"
784 - "je convertdone\n"
785 -
786 - "movzbl (%edi),%eax\n"
787 - "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
788 - "movzbl (%esi),%eax\n"
789 - "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
790 - "movzbl (%edx),%eax\n"
791 - "movq kCoefficientsRgbY(,%eax,8),%mm1\n"
792 - "paddsw %mm0,%mm1\n"
793 - "psraw $0x6,%mm1\n"
794 - "packuswb %mm1,%mm1\n"
795 - "movd %mm1,0x0(%ebp)\n"
796 -"convertdone:"
797 - "popa\n"
798 - "ret\n"
799 -);
800 -
801 -
802 -void ScaleYUVToRGB32Row(const uint8* y_buf,
803 - const uint8* u_buf,
804 - const uint8* v_buf,
805 - uint8* rgb_buf,
806 - int width,
807 - int scaled_dx);
808 -
809 - asm(
810 - ".global ScaleYUVToRGB32Row\n"
811 -"ScaleYUVToRGB32Row:\n"
812 - "pusha\n"
813 - "mov 0x24(%esp),%edx\n"
814 - "mov 0x28(%esp),%edi\n"
815 - "mov 0x2c(%esp),%esi\n"
816 - "mov 0x30(%esp),%ebp\n"
817 - "mov 0x34(%esp),%ecx\n"
818 - "xor %ebx,%ebx\n"
819 - "jmp scaleend\n"
820 -
821 -"scaleloop:"
822 - "mov %ebx,%eax\n"
823 - "sar $0x5,%eax\n"
824 - "movzbl (%edi,%eax,1),%eax\n"
825 - "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
826 - "mov %ebx,%eax\n"
827 - "sar $0x5,%eax\n"
828 - "movzbl (%esi,%eax,1),%eax\n"
829 - "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
830 - "mov %ebx,%eax\n"
831 - "add 0x38(%esp),%ebx\n"
832 - "sar $0x4,%eax\n"
833 - "movzbl (%edx,%eax,1),%eax\n"
834 - "movq kCoefficientsRgbY(,%eax,8),%mm1\n"
835 - "mov %ebx,%eax\n"
836 - "add 0x38(%esp),%ebx\n"
837 - "sar $0x4,%eax\n"
838 - "movzbl (%edx,%eax,1),%eax\n"
839 - "movq kCoefficientsRgbY(,%eax,8),%mm2\n"
840 - "paddsw %mm0,%mm1\n"
841 - "paddsw %mm0,%mm2\n"
842 - "psraw $0x6,%mm1\n"
843 - "psraw $0x6,%mm2\n"
844 - "packuswb %mm2,%mm1\n"
845 - "movntq %mm1,0x0(%ebp)\n"
846 - "add $0x8,%ebp\n"
847 -"scaleend:"
848 - "sub $0x2,%ecx\n"
849 - "jns scaleloop\n"
850 -
851 - "and $0x1,%ecx\n"
852 - "je scaledone\n"
853 -
854 - "mov %ebx,%eax\n"
855 - "sar $0x5,%eax\n"
856 - "movzbl (%edi,%eax,1),%eax\n"
857 - "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n"
858 - "mov %ebx,%eax\n"
859 - "sar $0x5,%eax\n"
860 - "movzbl (%esi,%eax,1),%eax\n"
861 - "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n"
862 - "mov %ebx,%eax\n"
863 - "sar $0x4,%eax\n"
864 - "movzbl (%edx,%eax,1),%eax\n"
865 - "movq kCoefficientsRgbY(,%eax,8),%mm1\n"
866 - "paddsw %mm0,%mm1\n"
867 - "psraw $0x6,%mm1\n"
868 - "packuswb %mm1,%mm1\n"
869 - "movd %mm1,0x0(%ebp)\n"
870 -
871 -"scaledone:"
872 - "popa\n"
873 - "ret\n"
874 -);
875 -
876 -#endif
877 -
878 -#else // USE_MMX
879
880 // Reference version of YUV converter.
881 static const int kClipTableSize = 256;
882 static const int kClipOverflow = 288; // Cb max is 535.
883
884 static uint8 kRgbClipTable[kClipOverflow +
885 kClipTableSize +
886 kClipOverflow] = {
887 @@ -651,17 +149,17 @@ static inline void YuvPixel(uint8 y,
888
889 int32 C298a = ((static_cast<int32>(y) - 16) * 298 + 128);
890 *reinterpret_cast<uint32*>(rgb_buf) = (clip(C298a + cb)) |
891 (clip(C298a + cg) << 8) |
892 (clip(C298a + cr) << 16) |
893 (0xff000000);
894 }
895
896 -void FastConvertYUVToRGB32Row(const uint8* y_buf,
897 +void FastConvertYUVToRGB32Row_C(const uint8* y_buf,
898 const uint8* u_buf,
899 const uint8* v_buf,
900 uint8* rgb_buf,
901 int width) {
902 for (int x = 0; x < width; x += 2) {
903 uint8 u = u_buf[x >> 1];
904 uint8 v = v_buf[x >> 1];
905 uint8 y0 = y_buf[x];
906 @@ -673,27 +171,26 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf,
907 rgb_buf += 8; // Advance 2 pixels.
908 }
909 }
910
911 // 28.4 fixed point is used. A shift by 4 isolates the integer.
912 // A shift by 5 is used to further subsample the chrominence channels.
913 // & 15 isolates the fixed point fraction. >> 2 to get the upper 2 bits,
914 // for 1/4 pixel accurate interpolation.
915 -void ScaleYUVToRGB32Row(const uint8* y_buf,
916 +void ScaleYUVToRGB32Row_C(const uint8* y_buf,
917 const uint8* u_buf,
918 const uint8* v_buf,
919 uint8* rgb_buf,
920 int width,
921 int scaled_dx) {
922 int scaled_x = 0;
923 for (int x = 0; x < width; ++x) {
924 uint8 u = u_buf[scaled_x >> 5];
925 uint8 v = v_buf[scaled_x >> 5];
926 uint8 y0 = y_buf[scaled_x >> 4];
927 YuvPixel(y0, u, v, rgb_buf);
928 rgb_buf += 4;
929 scaled_x += scaled_dx;
930 }
931 }
932 -#endif // USE_MMX
933 } // extern "C"
934
935 diff --git b/gfx/ycbcr/yuv_row_linux.cpp a/gfx/ycbcr/yuv_row_linux.cpp
936 index 4a20777..eeb78f6 100644
937 --- b/gfx/ycbcr/yuv_row_linux.cpp
938 +++ a/gfx/ycbcr/yuv_row_linux.cpp
939 @@ -1,25 +1,20 @@
940 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
941 // Use of this source code is governed by a BSD-style license that can be
942 // found in the LICENSE file.
943
944 -#include "media/base/yuv_row.h"
945 +#include "yuv_row.h"
946
947 -#ifdef _DEBUG
948 -#include "base/logging.h"
949 -#else
950 #define DCHECK(a)
951 -#endif
952
953 // TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac.
954 // TODO(fbarchard): Do 64 bit version.
955
956 extern "C" {
957 -#if USE_MMX
958
959 #define RGBY(i) { \
960 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
961 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
962 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
963 0 \
964 }
965
966 @@ -234,21 +229,16 @@ MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = {
967 RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB),
968 RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF),
969 RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3),
970 RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7),
971 RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB),
972 RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF),
973 };
974
975 -#undef RGBY
976 -#undef RGBU
977 -#undef RGBV
978 -#undef MMX_ALIGNED
979 -
980 #if defined(ARCH_CPU_X86_64)
981
982 // AMD64 ABI uses register paremters.
983 void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi
984 const uint8* u_buf, // rsi
985 const uint8* v_buf, // rdx
986 uint8* rgb_buf, // rcx
987 int width) { // r8
988 @@ -376,17 +366,16 @@ void ScaleYUVToRGB32Row(const uint8* y_buf, // rdi
989
990 #else
991
992 void FastConvertYUVToRGB32Row(const uint8* y_buf,
993 const uint8* u_buf,
994 const uint8* v_buf,
995 uint8* rgb_buf,
996 int width);
997 -
998 asm(
999 ".global FastConvertYUVToRGB32Row\n"
1000 "FastConvertYUVToRGB32Row:\n"
1001 "pusha\n"
1002 "mov 0x24(%esp),%edx\n"
1003 "mov 0x28(%esp),%edi\n"
1004 "mov 0x2c(%esp),%esi\n"
1005 "mov 0x30(%esp),%ebp\n"
1006 @@ -505,195 +494,10 @@ void ScaleYUVToRGB32Row(const uint8* y_buf,
1007 "movd %mm1,0x0(%ebp)\n"
1008
1009 "scaledone:"
1010 "popa\n"
1011 "ret\n"
1012 );
1013
1014 #endif
1015 -
1016 -#else // USE_MMX
1017 -
1018 -// Reference version of YUV converter.
1019 -static const int kClipTableSize = 256;
1020 -static const int kClipOverflow = 288; // Cb max is 535.
1021 -
1022 -static uint8 kRgbClipTable[kClipOverflow +
1023 - kClipTableSize +
1024 - kClipOverflow] = {
1025 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 288 underflow values
1026 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // clipped to 0.
1027 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1028 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1029 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1030 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1031 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1032 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1033 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1034 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1035 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1036 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1037 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1038 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1039 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1040 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1041 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1042 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1043 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1044 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1045 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1046 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1047 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1048 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1049 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1050 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1051 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1052 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1053 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1054 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1055 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1056 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1057 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1058 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1059 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1060 - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1061 - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // Unclipped values.
1062 - 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
1063 - 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1064 - 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
1065 - 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
1066 - 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
1067 - 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
1068 - 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
1069 - 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
1070 - 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F,
1071 - 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
1072 - 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F,
1073 - 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
1074 - 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
1075 - 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
1076 - 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F,
1077 - 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
1078 - 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
1079 - 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
1080 - 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F,
1081 - 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
1082 - 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF,
1083 - 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7,
1084 - 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF,
1085 - 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
1086 - 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF,
1087 - 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
1088 - 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
1089 - 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
1090 - 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF,
1091 - 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
1092 - 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF,
1093 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 288 overflow values
1094 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // clipped to 255.
1095 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1096 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1097 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1098 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1099 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1100 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1101 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1102 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1103 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1104 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1105 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1106 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1107 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1108 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1109 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1110 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1111 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1112 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1113 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1114 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1115 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1116 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1117 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1118 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1119 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1120 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1121 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1122 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1123 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1124 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1125 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1126 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1127 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1128 - 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1129 -};
1130 -
1131 -// Clip an rgb channel value to 0..255 range.
1132 -// Source is signed fixed point 8.8.
1133 -// Table allows for values to underflow or overflow by 128.
1134 -// Therefore source range is -128 to 384.
1135 -// Output clips to unsigned 0 to 255.
1136 -static inline uint32 clip(int32 value) {
1137 - DCHECK(((value >> 8) + kClipOverflow) >= 0);
1138 - DCHECK(((value >> 8) + kClipOverflow) <
1139 - (kClipOverflow + kClipTableSize + kClipOverflow));
1140 - return static_cast<uint32>(kRgbClipTable[((value) >> 8) + kClipOverflow]);
1141 -}
1142 -
1143 -static inline void YuvPixel(uint8 y,
1144 - uint8 u,
1145 - uint8 v,
1146 - uint8* rgb_buf) {
1147 - int32 d = static_cast<int32>(u) - 128;
1148 - int32 e = static_cast<int32>(v) - 128;
1149 -
1150 - int32 cb = (516 * d + 128);
1151 - int32 cg = (- 100 * d - 208 * e + 128);
1152 - int32 cr = (409 * e + 128);
1153 -
1154 - int32 C298a = ((static_cast<int32>(y) - 16) * 298 + 128);
1155 - *reinterpret_cast<uint32*>(rgb_buf) = (clip(C298a + cb)) |
1156 - (clip(C298a + cg) << 8) |
1157 - (clip(C298a + cr) << 16) |
1158 - (0xff000000);
1159 -}
1160 -
1161 -void FastConvertYUVToRGB32Row(const uint8* y_buf,
1162 - const uint8* u_buf,
1163 - const uint8* v_buf,
1164 - uint8* rgb_buf,
1165 - int width) {
1166 - for (int x = 0; x < width; x += 2) {
1167 - uint8 u = u_buf[x >> 1];
1168 - uint8 v = v_buf[x >> 1];
1169 - uint8 y0 = y_buf[x];
1170 - YuvPixel(y0, u, v, rgb_buf);
1171 - if ((x + 1) < width) {
1172 - uint8 y1 = y_buf[x + 1];
1173 - YuvPixel(y1, u, v, rgb_buf + 4);
1174 - }
1175 - rgb_buf += 8; // Advance 2 pixels.
1176 - }
1177 -}
1178 -
1179 -// 28.4 fixed point is used. A shift by 4 isolates the integer.
1180 -// A shift by 5 is used to further subsample the chrominence channels.
1181 -// & 15 isolates the fixed point fraction. >> 2 to get the upper 2 bits,
1182 -// for 1/4 pixel accurate interpolation.
1183 -void ScaleYUVToRGB32Row(const uint8* y_buf,
1184 - const uint8* u_buf,
1185 - const uint8* v_buf,
1186 - uint8* rgb_buf,
1187 - int width,
1188 - int scaled_dx) {
1189 - int scaled_x = 0;
1190 - for (int x = 0; x < width; ++x) {
1191 - uint8 u = u_buf[scaled_x >> 5];
1192 - uint8 v = v_buf[scaled_x >> 5];
1193 - uint8 y0 = y_buf[scaled_x >> 4];
1194 - YuvPixel(y0, u, v, rgb_buf);
1195 - rgb_buf += 4;
1196 - scaled_x += scaled_dx;
1197 - }
1198 -}
1199 -#endif // USE_MMX
1200 } // extern "C"
1201
1202 diff --git b/gfx/ycbcr/yuv_row_mac.cpp a/gfx/ycbcr/yuv_row_mac.cpp
1203 index 39c252d..aa40aac 100644
1204 --- b/gfx/ycbcr/yuv_row_mac.cpp
1205 +++ a/gfx/ycbcr/yuv_row_mac.cpp
1206 @@ -1,13 +1,13 @@
1207 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
1208 // Use of this source code is governed by a BSD-style license that can be
1209 // found in the LICENSE file.
1210
1211 -#include "media/base/yuv_row.h"
1212 +#include "yuv_row.h"
1213
1214 // TODO(fbarchard): Do 64 bit version.
1215
1216 extern "C" {
1217
1218 #define RGBY(i) { \
1219 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
1220 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
1221 diff --git b/gfx/ycbcr/yuv_row_win.cpp a/gfx/ycbcr/yuv_row_win.cpp
1222 index 1e11d94..a77a16f 100644
1223 --- b/gfx/ycbcr/yuv_row_win.cpp
1224 +++ a/gfx/ycbcr/yuv_row_win.cpp
1225 @@ -1,13 +1,13 @@
1226 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
1227 // Use of this source code is governed by a BSD-style license that can be
1228 // found in the LICENSE file.
1229
1230 -#include "media/base/yuv_row.h"
1231 +#include "yuv_row.h"
1232
1233 extern "C" {
1234 #define RGBY(i) { \
1235 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
1236 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
1237 static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \
1238 0 \
1239 }
git mirror of mozilla-central