?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add more logging to pin down Mac GPU bots random crashes at browser startup.
[chromium-blink-merge.git] / third_party / libwebp / enc / picture_csp.c
blob7875f625b7c36368bb2787d6f5e271a37764edc2
1 // Copyright 2014 Google Inc. All Rights Reserved.
2 //
3 // Use of this source code is governed by a BSD-style license
4 // that can be found in the COPYING file in the root of the source
5 // tree. An additional intellectual property rights grant can be found
6 // in the file PATENTS. All contributing project authors may
7 // be found in the AUTHORS file in the root of the source tree.
8 // -----------------------------------------------------------------------------
9 //
10 // WebPPicture utils for colorspace conversion
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13
14 #include <assert.h>
15 #include <stdlib.h>
16 #include <math.h>
17
18 #include "./vp8enci.h"
19 #include "../utils/random.h"
20 #include "../utils/utils.h"
21 #include "../dsp/yuv.h"
22
23 // Uncomment to disable gamma-compression during RGB->U/V averaging
24 #define USE_GAMMA_COMPRESSION
25
26 // If defined, use table to compute x / alpha.
27 #define USE_INVERSE_ALPHA_TABLE
28
29 static const union {
30 uint32_t argb;
31 uint8_t bytes[4];
32 } test_endian = { 0xff000000u };
33 #define ALPHA_IS_LAST (test_endian.bytes[3] == 0xff)
34
35 static WEBP_INLINE uint32_t MakeARGB32(int a, int r, int g, int b) {
36 return (((uint32_t)a << 24) | (r << 16) | (g << 8) | b);
37 }
38
39 //------------------------------------------------------------------------------
40 // Detection of non-trivial transparency
41
42 // Returns true if alpha[] has non-0xff values.
43 static int CheckNonOpaque(const uint8_t* alpha, int width, int height,
44 int x_step, int y_step) {
45 if (alpha == NULL) return 0;
46 while (height-- > 0) {
47 int x;
48 for (x = 0; x < width * x_step; x += x_step) {
49 if (alpha[x] != 0xff) return 1; // TODO(skal): check 4/8 bytes at a time.
50 }
51 alpha += y_step;
52 }
53 return 0;
54 }
55
56 // Checking for the presence of non-opaque alpha.
57 int WebPPictureHasTransparency(const WebPPicture* picture) {
58 if (picture == NULL) return 0;
59 if (!picture->use_argb) {
60 return CheckNonOpaque(picture->a, picture->width, picture->height,
61 1, picture->a_stride);
62 } else {
63 int x, y;
64 const uint32_t* argb = picture->argb;
65 if (argb == NULL) return 0;
66 for (y = 0; y < picture->height; ++y) {
67 for (x = 0; x < picture->width; ++x) {
68 if (argb[x] < 0xff000000u) return 1; // test any alpha values != 0xff
69 }
70 argb += picture->argb_stride;
71 }
72 }
73 return 0;
74 }
75
76 //------------------------------------------------------------------------------
77 // Code for gamma correction
78
79 #if defined(USE_GAMMA_COMPRESSION)
80
81 // gamma-compensates loss of resolution during chroma subsampling
82 #define kGamma 0.80 // for now we use a different gamma value than kGammaF
83 #define kGammaFix 12 // fixed-point precision for linear values
84 #define kGammaScale ((1 << kGammaFix) - 1)
85 #define kGammaTabFix 7 // fixed-point fractional bits precision
86 #define kGammaTabScale (1 << kGammaTabFix)
87 #define kGammaTabRounder (kGammaTabScale >> 1)
88 #define kGammaTabSize (1 << (kGammaFix - kGammaTabFix))
89
90 static int kLinearToGammaTab[kGammaTabSize + 1];
91 static uint16_t kGammaToLinearTab[256];
92 static int kGammaTablesOk = 0;
93
94 static void InitGammaTables(void) {
95 if (!kGammaTablesOk) {
96 int v;
97 const double scale = (double)(1 << kGammaTabFix) / kGammaScale;
98 const double norm = 1. / 255.;
99 for (v = 0; v <= 255; ++v) {
100 kGammaToLinearTab[v] =
101 (uint16_t)(pow(norm * v, kGamma) * kGammaScale + .5);
102 }
103 for (v = 0; v <= kGammaTabSize; ++v) {
104 kLinearToGammaTab[v] = (int)(255. * pow(scale * v, 1. / kGamma) + .5);
105 }
106 kGammaTablesOk = 1;
107 }
108 }
109
110 static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) {
111 return kGammaToLinearTab[v];
112 }
113
114 static WEBP_INLINE int Interpolate(int v) {
115 const int tab_pos = v >> (kGammaTabFix + 2); // integer part
116 const int x = v & ((kGammaTabScale << 2) - 1); // fractional part
117 const int v0 = kLinearToGammaTab[tab_pos];
118 const int v1 = kLinearToGammaTab[tab_pos + 1];
119 const int y = v1 * x + v0 * ((kGammaTabScale << 2) - x); // interpolate
120 assert(tab_pos + 1 < kGammaTabSize + 1);
121 return y;
122 }
123
124 // Convert a linear value 'v' to YUV_FIX+2 fixed-point precision
125 // U/V value, suitable for RGBToU/V calls.
126 static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
127 const int y = Interpolate(base_value << shift); // final uplifted value
128 return (y + kGammaTabRounder) >> kGammaTabFix; // descale
129 }
130
131 #else
132
133 static void InitGammaTables(void) {}
134 static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) { return v; }
135 static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
136 return (int)(base_value << shift);
137 }
138
139 #endif // USE_GAMMA_COMPRESSION
140
141 //------------------------------------------------------------------------------
142 // RGB -> YUV conversion
143
144 static int RGBToY(int r, int g, int b, VP8Random* const rg) {
145 return (rg == NULL) ? VP8RGBToY(r, g, b, YUV_HALF)
146 : VP8RGBToY(r, g, b, VP8RandomBits(rg, YUV_FIX));
147 }
148
149 static int RGBToU(int r, int g, int b, VP8Random* const rg) {
150 return (rg == NULL) ? VP8RGBToU(r, g, b, YUV_HALF << 2)
151 : VP8RGBToU(r, g, b, VP8RandomBits(rg, YUV_FIX + 2));
152 }
153
154 static int RGBToV(int r, int g, int b, VP8Random* const rg) {
155 return (rg == NULL) ? VP8RGBToV(r, g, b, YUV_HALF << 2)
156 : VP8RGBToV(r, g, b, VP8RandomBits(rg, YUV_FIX + 2));
157 }
158
159 //------------------------------------------------------------------------------
160 // Smart RGB->YUV conversion
161
162 static const int kNumIterations = 6;
163 static const int kMinDimensionIterativeConversion = 4;
164
165 // We use a-priori a different precision for storing RGB and Y/W components
166 // We could use YFIX=0 and only uint8_t for fixed_y_t, but it produces some
167 // banding sometimes. Better use extra precision.
168 // TODO(skal): cleanup once TFIX/YFIX values are fixed.
169
170 typedef int16_t fixed_t; // signed type with extra TFIX precision for UV
171 typedef uint16_t fixed_y_t; // unsigned type with extra YFIX precision for W
172 #define TFIX 6 // fixed-point precision of RGB
173 #define YFIX 2 // fixed point precision for Y/W
174
175 #define THALF ((1 << TFIX) >> 1)
176 #define MAX_Y_T ((256 << YFIX) - 1)
177 #define TROUNDER (1 << (YUV_FIX + TFIX - 1))
178
179 #if defined(USE_GAMMA_COMPRESSION)
180
181 // float variant of gamma-correction
182 // We use tables of different size and precision, along with a 'real-world'
183 // Gamma value close to ~2.
184 #define kGammaF 2.2
185 static float kGammaToLinearTabF[MAX_Y_T + 1]; // size scales with Y_FIX
186 static float kLinearToGammaTabF[kGammaTabSize + 2];
187 static int kGammaTablesFOk = 0;
188
189 static void InitGammaTablesF(void) {
190 if (!kGammaTablesFOk) {
191 int v;
192 const double norm = 1. / MAX_Y_T;
193 const double scale = 1. / kGammaTabSize;
194 for (v = 0; v <= MAX_Y_T; ++v) {
195 kGammaToLinearTabF[v] = (float)pow(norm * v, kGammaF);
196 }
197 for (v = 0; v <= kGammaTabSize; ++v) {
198 kLinearToGammaTabF[v] = (float)(MAX_Y_T * pow(scale * v, 1. / kGammaF));
199 }
200 // to prevent small rounding errors to cause read-overflow:
201 kLinearToGammaTabF[kGammaTabSize + 1] = kLinearToGammaTabF[kGammaTabSize];
202 kGammaTablesFOk = 1;
203 }
204 }
205
206 static WEBP_INLINE float GammaToLinearF(int v) {
207 return kGammaToLinearTabF[v];
208 }
209
210 static WEBP_INLINE float LinearToGammaF(float value) {
211 const float v = value * kGammaTabSize;
212 const int tab_pos = (int)v;
213 const float x = v - (float)tab_pos; // fractional part
214 const float v0 = kLinearToGammaTabF[tab_pos + 0];
215 const float v1 = kLinearToGammaTabF[tab_pos + 1];
216 const float y = v1 * x + v0 * (1.f - x); // interpolate
217 return y;
218 }
219
220 #else
221
222 static void InitGammaTablesF(void) {}
223 static WEBP_INLINE float GammaToLinearF(int v) {
224 const float norm = 1.f / MAX_Y_T;
225 return norm * v;
226 }
227 static WEBP_INLINE float LinearToGammaF(float value) {
228 return MAX_Y_T * value;
229 }
230
231 #endif // USE_GAMMA_COMPRESSION
232
233 //------------------------------------------------------------------------------
234
235 // precision: YFIX -> TFIX
236 static WEBP_INLINE int FixedYToW(int v) {
237 #if TFIX == YFIX
238 return v;
239 #elif TFIX >= YFIX
240 return v << (TFIX - YFIX);
241 #else
242 return v >> (YFIX - TFIX);
243 #endif
244 }
245
246 static WEBP_INLINE int FixedWToY(int v) {
247 #if TFIX == YFIX
248 return v;
249 #elif YFIX >= TFIX
250 return v << (YFIX - TFIX);
251 #else
252 return v >> (TFIX - YFIX);
253 #endif
254 }
255
256 static uint8_t clip_8b(fixed_t v) {
257 return (!(v & ~0xff)) ? (uint8_t)v : (v < 0) ? 0u : 255u;
258 }
259
260 static fixed_y_t clip_y(int y) {
261 return (!(y & ~MAX_Y_T)) ? (fixed_y_t)y : (y < 0) ? 0 : MAX_Y_T;
262 }
263
264 // precision: TFIX -> YFIX
265 static fixed_y_t clip_fixed_t(fixed_t v) {
266 const int y = FixedWToY(v);
267 const fixed_y_t w = clip_y(y);
268 return w;
269 }
270
271 //------------------------------------------------------------------------------
272
273 static int RGBToGray(int r, int g, int b) {
274 const int luma = 19595 * r + 38470 * g + 7471 * b + YUV_HALF;
275 return (luma >> YUV_FIX);
276 }
277
278 static float RGBToGrayF(float r, float g, float b) {
279 return 0.299f * r + 0.587f * g + 0.114f * b;
280 }
281
282 static float ScaleDown(int a, int b, int c, int d) {
283 const float A = GammaToLinearF(a);
284 const float B = GammaToLinearF(b);
285 const float C = GammaToLinearF(c);
286 const float D = GammaToLinearF(d);
287 return LinearToGammaF(0.25f * (A + B + C + D));
288 }
289
290 static WEBP_INLINE void UpdateW(const fixed_y_t* src, fixed_y_t* dst, int len) {
291 while (len-- > 0) {
292 const float R = GammaToLinearF(src[0]);
293 const float G = GammaToLinearF(src[1]);
294 const float B = GammaToLinearF(src[2]);
295 const float Y = RGBToGrayF(R, G, B);
296 *dst++ = (fixed_y_t)(LinearToGammaF(Y) + .5);
297 src += 3;
298 }
299 }
300
301 static WEBP_INLINE void UpdateChroma(const fixed_y_t* src1,
302 const fixed_y_t* src2,
303 fixed_t* dst, fixed_y_t* tmp, int len) {
304 while (len--> 0) {
305 const float r = ScaleDown(src1[0], src1[3], src2[0], src2[3]);
306 const float g = ScaleDown(src1[1], src1[4], src2[1], src2[4]);
307 const float b = ScaleDown(src1[2], src1[5], src2[2], src2[5]);
308 const float W = RGBToGrayF(r, g, b);
309 dst[0] = (fixed_t)FixedYToW((int)(r - W));
310 dst[1] = (fixed_t)FixedYToW((int)(g - W));
311 dst[2] = (fixed_t)FixedYToW((int)(b - W));
312 dst += 3;
313 src1 += 6;
314 src2 += 6;
315 if (tmp != NULL) {
316 tmp[0] = tmp[1] = clip_y((int)(W + .5));
317 tmp += 2;
318 }
319 }
320 }
321
322 //------------------------------------------------------------------------------
323
324 static WEBP_INLINE int Filter(const fixed_t* const A, const fixed_t* const B,
325 int rightwise) {
326 int v;
327 if (!rightwise) {
328 v = (A[0] * 9 + A[-3] * 3 + B[0] * 3 + B[-3]);
329 } else {
330 v = (A[0] * 9 + A[+3] * 3 + B[0] * 3 + B[+3]);
331 }
332 return (v + 8) >> 4;
333 }
334
335 static WEBP_INLINE int Filter2(int A, int B) { return (A * 3 + B + 2) >> 2; }
336
337 //------------------------------------------------------------------------------
338
339 // 8bit -> YFIX
340 static WEBP_INLINE fixed_y_t UpLift(uint8_t a) {
341 return ((fixed_y_t)a << YFIX) | (1 << (YFIX - 1));
342 }
343
344 static void ImportOneRow(const uint8_t* const r_ptr,
345 const uint8_t* const g_ptr,
346 const uint8_t* const b_ptr,
347 int step,
348 int pic_width,
349 fixed_y_t* const dst) {
350 int i;
351 for (i = 0; i < pic_width; ++i) {
352 const int off = i * step;
353 dst[3 * i + 0] = UpLift(r_ptr[off]);
354 dst[3 * i + 1] = UpLift(g_ptr[off]);
355 dst[3 * i + 2] = UpLift(b_ptr[off]);
356 }
357 if (pic_width & 1) { // replicate rightmost pixel
358 memcpy(dst + 3 * pic_width, dst + 3 * (pic_width - 1), 3 * sizeof(*dst));
359 }
360 }
361
362 static void InterpolateTwoRows(const fixed_y_t* const best_y,
363 const fixed_t* const prev_uv,
364 const fixed_t* const cur_uv,
365 const fixed_t* const next_uv,
366 int w,
367 fixed_y_t* const out1,
368 fixed_y_t* const out2) {
369 int i, k;
370 { // special boundary case for i==0
371 const int W0 = FixedYToW(best_y[0]);
372 const int W1 = FixedYToW(best_y[w]);
373 for (k = 0; k <= 2; ++k) {
374 out1[k] = clip_fixed_t(Filter2(cur_uv[k], prev_uv[k]) + W0);
375 out2[k] = clip_fixed_t(Filter2(cur_uv[k], next_uv[k]) + W1);
376 }
377 }
378 for (i = 1; i < w - 1; ++i) {
379 const int W0 = FixedYToW(best_y[i + 0]);
380 const int W1 = FixedYToW(best_y[i + w]);
381 const int off = 3 * (i >> 1);
382 for (k = 0; k <= 2; ++k) {
383 const int tmp0 = Filter(cur_uv + off + k, prev_uv + off + k, i & 1);
384 const int tmp1 = Filter(cur_uv + off + k, next_uv + off + k, i & 1);
385 out1[3 * i + k] = clip_fixed_t(tmp0 + W0);
386 out2[3 * i + k] = clip_fixed_t(tmp1 + W1);
387 }
388 }
389 { // special boundary case for i == w - 1
390 const int W0 = FixedYToW(best_y[i + 0]);
391 const int W1 = FixedYToW(best_y[i + w]);
392 const int off = 3 * (i >> 1);
393 for (k = 0; k <= 2; ++k) {
394 out1[3 * i + k] =
395 clip_fixed_t(Filter2(cur_uv[off + k], prev_uv[off + k]) + W0);
396 out2[3 * i + k] =
397 clip_fixed_t(Filter2(cur_uv[off + k], next_uv[off + k]) + W1);
398 }
399 }
400 }
401
402 static WEBP_INLINE uint8_t ConvertRGBToY(int r, int g, int b) {
403 const int luma = 16839 * r + 33059 * g + 6420 * b + TROUNDER;
404 return clip_8b(16 + (luma >> (YUV_FIX + TFIX)));
405 }
406
407 static WEBP_INLINE uint8_t ConvertRGBToU(int r, int g, int b) {
408 const int u = -9719 * r - 19081 * g + 28800 * b + TROUNDER;
409 return clip_8b(128 + (u >> (YUV_FIX + TFIX)));
410 }
411
412 static WEBP_INLINE uint8_t ConvertRGBToV(int r, int g, int b) {
413 const int v = +28800 * r - 24116 * g - 4684 * b + TROUNDER;
414 return clip_8b(128 + (v >> (YUV_FIX + TFIX)));
415 }
416
417 static int ConvertWRGBToYUV(const fixed_y_t* const best_y,
418 const fixed_t* const best_uv,
419 WebPPicture* const picture) {
420 int i, j;
421 const int w = (picture->width + 1) & ~1;
422 const int h = (picture->height + 1) & ~1;
423 const int uv_w = w >> 1;
424 const int uv_h = h >> 1;
425 for (j = 0; j < picture->height; ++j) {
426 for (i = 0; i < picture->width; ++i) {
427 const int off = 3 * ((i >> 1) + (j >> 1) * uv_w);
428 const int off2 = i + j * picture->y_stride;
429 const int W = FixedYToW(best_y[i + j * w]);
430 const int r = best_uv[off + 0] + W;
431 const int g = best_uv[off + 1] + W;
432 const int b = best_uv[off + 2] + W;
433 picture->y[off2] = ConvertRGBToY(r, g, b);
434 }
435 }
436 for (j = 0; j < uv_h; ++j) {
437 uint8_t* const dst_u = picture->u + j * picture->uv_stride;
438 uint8_t* const dst_v = picture->v + j * picture->uv_stride;
439 for (i = 0; i < uv_w; ++i) {
440 const int off = 3 * (i + j * uv_w);
441 const int r = best_uv[off + 0];
442 const int g = best_uv[off + 1];
443 const int b = best_uv[off + 2];
444 dst_u[i] = ConvertRGBToU(r, g, b);
445 dst_v[i] = ConvertRGBToV(r, g, b);
446 }
447 }
448 return 1;
449 }
450
451 //------------------------------------------------------------------------------
452 // Main function
453
454 #define SAFE_ALLOC(W, H, T) ((T*)WebPSafeMalloc((W) * (H), sizeof(T)))
455
456 static int PreprocessARGB(const uint8_t* const r_ptr,
457 const uint8_t* const g_ptr,
458 const uint8_t* const b_ptr,
459 int step, int rgb_stride,
460 WebPPicture* const picture) {
461 // we expand the right/bottom border if needed
462 const int w = (picture->width + 1) & ~1;
463 const int h = (picture->height + 1) & ~1;
464 const int uv_w = w >> 1;
465 const int uv_h = h >> 1;
466 int i, j, iter;
467
468 // TODO(skal): allocate one big memory chunk. But for now, it's easier
469 // for valgrind debugging to have several chunks.
470 fixed_y_t* const tmp_buffer = SAFE_ALLOC(w * 3, 2, fixed_y_t); // scratch
471 fixed_y_t* const best_y = SAFE_ALLOC(w, h, fixed_y_t);
472 fixed_y_t* const target_y = SAFE_ALLOC(w, h, fixed_y_t);
473 fixed_y_t* const best_rgb_y = SAFE_ALLOC(w, 2, fixed_y_t);
474 fixed_t* const best_uv = SAFE_ALLOC(uv_w * 3, uv_h, fixed_t);
475 fixed_t* const target_uv = SAFE_ALLOC(uv_w * 3, uv_h, fixed_t);
476 fixed_t* const best_rgb_uv = SAFE_ALLOC(uv_w * 3, 1, fixed_t);
477 int ok;
478
479 if (best_y == NULL || best_uv == NULL ||
480 target_y == NULL || target_uv == NULL ||
481 best_rgb_y == NULL || best_rgb_uv == NULL ||
482 tmp_buffer == NULL) {
483 ok = WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
484 goto End;
485 }
486 assert(picture->width >= kMinDimensionIterativeConversion);
487 assert(picture->height >= kMinDimensionIterativeConversion);
488
489 // Import RGB samples to W/RGB representation.
490 for (j = 0; j < picture->height; j += 2) {
491 const int is_last_row = (j == picture->height - 1);
492 fixed_y_t* const src1 = tmp_buffer;
493 fixed_y_t* const src2 = tmp_buffer + 3 * w;
494 const int off1 = j * rgb_stride;
495 const int off2 = off1 + rgb_stride;
496 const int uv_off = (j >> 1) * 3 * uv_w;
497 fixed_y_t* const dst_y = best_y + j * w;
498
499 // prepare two rows of input
500 ImportOneRow(r_ptr + off1, g_ptr + off1, b_ptr + off1,
501 step, picture->width, src1);
502 if (!is_last_row) {
503 ImportOneRow(r_ptr + off2, g_ptr + off2, b_ptr + off2,
504 step, picture->width, src2);
505 } else {
506 memcpy(src2, src1, 3 * w * sizeof(*src2));
507 }
508 UpdateW(src1, target_y + (j + 0) * w, w);
509 UpdateW(src2, target_y + (j + 1) * w, w);
510 UpdateChroma(src1, src2, target_uv + uv_off, dst_y, uv_w);
511 memcpy(best_uv + uv_off, target_uv + uv_off, 3 * uv_w * sizeof(*best_uv));
512 memcpy(dst_y + w, dst_y, w * sizeof(*dst_y));
513 }
514
515 // Iterate and resolve clipping conflicts.
516 for (iter = 0; iter < kNumIterations; ++iter) {
517 int k;
518 const fixed_t* cur_uv = best_uv;
519 const fixed_t* prev_uv = best_uv;
520 for (j = 0; j < h; j += 2) {
521 fixed_y_t* const src1 = tmp_buffer;
522 fixed_y_t* const src2 = tmp_buffer + 3 * w;
523
524 {
525 const fixed_t* const next_uv = cur_uv + ((j < h - 2) ? 3 * uv_w : 0);
526 InterpolateTwoRows(best_y + j * w, prev_uv, cur_uv, next_uv,
527 w, src1, src2);
528 prev_uv = cur_uv;
529 cur_uv = next_uv;
530 }
531
532 UpdateW(src1, best_rgb_y + 0 * w, w);
533 UpdateW(src2, best_rgb_y + 1 * w, w);
534 UpdateChroma(src1, src2, best_rgb_uv, NULL, uv_w);
535
536 // update two rows of Y and one row of RGB
537 for (i = 0; i < 2 * w; ++i) {
538 const int off = i + j * w;
539 const int diff_y = target_y[off] - best_rgb_y[i];
540 const int new_y = (int)best_y[off] + diff_y;
541 best_y[off] = clip_y(new_y);
542 }
543 for (i = 0; i < uv_w; ++i) {
544 const int off = 3 * (i + (j >> 1) * uv_w);
545 int W;
546 for (k = 0; k <= 2; ++k) {
547 const int diff_uv = (int)target_uv[off + k] - best_rgb_uv[3 * i + k];
548 best_uv[off + k] += diff_uv;
549 }
550 W = RGBToGray(best_uv[off + 0], best_uv[off + 1], best_uv[off + 2]);
551 for (k = 0; k <= 2; ++k) {
552 best_uv[off + k] -= W;
553 }
554 }
555 }
556 // TODO(skal): add early-termination criterion
557 }
558
559 // final reconstruction
560 ok = ConvertWRGBToYUV(best_y, best_uv, picture);
561
562 End:
563 WebPSafeFree(best_y);
564 WebPSafeFree(best_uv);
565 WebPSafeFree(target_y);
566 WebPSafeFree(target_uv);
567 WebPSafeFree(best_rgb_y);
568 WebPSafeFree(best_rgb_uv);
569 WebPSafeFree(tmp_buffer);
570 return ok;
571 }
572 #undef SAFE_ALLOC
573
574 //------------------------------------------------------------------------------
575 // "Fast" regular RGB->YUV
576
577 #define SUM4(ptr, step) LinearToGamma( \
578 GammaToLinear((ptr)[0]) + \
579 GammaToLinear((ptr)[(step)]) + \
580 GammaToLinear((ptr)[rgb_stride]) + \
581 GammaToLinear((ptr)[rgb_stride + (step)]), 0) \
582
583 #define SUM2(ptr) \
584 LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
585
586 #define SUM2ALPHA(ptr) ((ptr)[0] + (ptr)[rgb_stride])
587 #define SUM4ALPHA(ptr) (SUM2ALPHA(ptr) + SUM2ALPHA((ptr) + 4))
588
589 #if defined(USE_INVERSE_ALPHA_TABLE)
590
591 static const int kAlphaFix = 19;
592 // Following table is (1 << kAlphaFix) / a. The (v * kInvAlpha[a]) >> kAlphaFix
593 // formula is then equal to v / a in most (99.6%) cases. Note that this table
594 // and constant are adjusted very tightly to fit 32b arithmetic.
595 // In particular, they use the fact that the operands for 'v / a' are actually
596 // derived as v = (a0.p0 + a1.p1 + a2.p2 + a3.p3) and a = a0 + a1 + a2 + a3
597 // with ai in [0..255] and pi in [0..1<<kGammaFix). The constraint to avoid
598 // overflow is: kGammaFix + kAlphaFix <= 31.
599 static const uint32_t kInvAlpha[4 * 0xff + 1] = {
600 0, /* alpha = 0 */
601 524288, 262144, 174762, 131072, 104857, 87381, 74898, 65536,
602 58254, 52428, 47662, 43690, 40329, 37449, 34952, 32768,
603 30840, 29127, 27594, 26214, 24966, 23831, 22795, 21845,
604 20971, 20164, 19418, 18724, 18078, 17476, 16912, 16384,
605 15887, 15420, 14979, 14563, 14169, 13797, 13443, 13107,
606 12787, 12483, 12192, 11915, 11650, 11397, 11155, 10922,
607 10699, 10485, 10280, 10082, 9892, 9709, 9532, 9362,
608 9198, 9039, 8886, 8738, 8594, 8456, 8322, 8192,
609 8065, 7943, 7825, 7710, 7598, 7489, 7384, 7281,
610 7182, 7084, 6990, 6898, 6808, 6721, 6636, 6553,
611 6472, 6393, 6316, 6241, 6168, 6096, 6026, 5957,
612 5890, 5825, 5761, 5698, 5637, 5577, 5518, 5461,
613 5405, 5349, 5295, 5242, 5190, 5140, 5090, 5041,
614 4993, 4946, 4899, 4854, 4809, 4766, 4723, 4681,
615 4639, 4599, 4559, 4519, 4481, 4443, 4405, 4369,
616 4332, 4297, 4262, 4228, 4194, 4161, 4128, 4096,
617 4064, 4032, 4002, 3971, 3942, 3912, 3883, 3855,
618 3826, 3799, 3771, 3744, 3718, 3692, 3666, 3640,
619 3615, 3591, 3566, 3542, 3518, 3495, 3472, 3449,
620 3426, 3404, 3382, 3360, 3339, 3318, 3297, 3276,
621 3256, 3236, 3216, 3196, 3177, 3158, 3139, 3120,
622 3102, 3084, 3066, 3048, 3030, 3013, 2995, 2978,
623 2962, 2945, 2928, 2912, 2896, 2880, 2864, 2849,
624 2833, 2818, 2803, 2788, 2774, 2759, 2744, 2730,
625 2716, 2702, 2688, 2674, 2661, 2647, 2634, 2621,
626 2608, 2595, 2582, 2570, 2557, 2545, 2532, 2520,
627 2508, 2496, 2484, 2473, 2461, 2449, 2438, 2427,
628 2416, 2404, 2394, 2383, 2372, 2361, 2351, 2340,
629 2330, 2319, 2309, 2299, 2289, 2279, 2269, 2259,
630 2250, 2240, 2231, 2221, 2212, 2202, 2193, 2184,
631 2175, 2166, 2157, 2148, 2139, 2131, 2122, 2114,
632 2105, 2097, 2088, 2080, 2072, 2064, 2056, 2048,
633 2040, 2032, 2024, 2016, 2008, 2001, 1993, 1985,
634 1978, 1971, 1963, 1956, 1949, 1941, 1934, 1927,
635 1920, 1913, 1906, 1899, 1892, 1885, 1879, 1872,
636 1865, 1859, 1852, 1846, 1839, 1833, 1826, 1820,
637 1814, 1807, 1801, 1795, 1789, 1783, 1777, 1771,
638 1765, 1759, 1753, 1747, 1741, 1736, 1730, 1724,
639 1718, 1713, 1707, 1702, 1696, 1691, 1685, 1680,
640 1675, 1669, 1664, 1659, 1653, 1648, 1643, 1638,
641 1633, 1628, 1623, 1618, 1613, 1608, 1603, 1598,
642 1593, 1588, 1583, 1579, 1574, 1569, 1565, 1560,
643 1555, 1551, 1546, 1542, 1537, 1533, 1528, 1524,
644 1519, 1515, 1510, 1506, 1502, 1497, 1493, 1489,
645 1485, 1481, 1476, 1472, 1468, 1464, 1460, 1456,
646 1452, 1448, 1444, 1440, 1436, 1432, 1428, 1424,
647 1420, 1416, 1413, 1409, 1405, 1401, 1398, 1394,
648 1390, 1387, 1383, 1379, 1376, 1372, 1368, 1365,
649 1361, 1358, 1354, 1351, 1347, 1344, 1340, 1337,
650 1334, 1330, 1327, 1323, 1320, 1317, 1314, 1310,
651 1307, 1304, 1300, 1297, 1294, 1291, 1288, 1285,
652 1281, 1278, 1275, 1272, 1269, 1266, 1263, 1260,
653 1257, 1254, 1251, 1248, 1245, 1242, 1239, 1236,
654 1233, 1230, 1227, 1224, 1222, 1219, 1216, 1213,
655 1210, 1208, 1205, 1202, 1199, 1197, 1194, 1191,
656 1188, 1186, 1183, 1180, 1178, 1175, 1172, 1170,
657 1167, 1165, 1162, 1159, 1157, 1154, 1152, 1149,
658 1147, 1144, 1142, 1139, 1137, 1134, 1132, 1129,
659 1127, 1125, 1122, 1120, 1117, 1115, 1113, 1110,
660 1108, 1106, 1103, 1101, 1099, 1096, 1094, 1092,
661 1089, 1087, 1085, 1083, 1081, 1078, 1076, 1074,
662 1072, 1069, 1067, 1065, 1063, 1061, 1059, 1057,
663 1054, 1052, 1050, 1048, 1046, 1044, 1042, 1040,
664 1038, 1036, 1034, 1032, 1030, 1028, 1026, 1024,
665 1022, 1020, 1018, 1016, 1014, 1012, 1010, 1008,
666 1006, 1004, 1002, 1000, 998, 996, 994, 992,
667 991, 989, 987, 985, 983, 981, 979, 978,
668 976, 974, 972, 970, 969, 967, 965, 963,
669 961, 960, 958, 956, 954, 953, 951, 949,
670 948, 946, 944, 942, 941, 939, 937, 936,
671 934, 932, 931, 929, 927, 926, 924, 923,
672 921, 919, 918, 916, 914, 913, 911, 910,
673 908, 907, 905, 903, 902, 900, 899, 897,
674 896, 894, 893, 891, 890, 888, 887, 885,
675 884, 882, 881, 879, 878, 876, 875, 873,
676 872, 870, 869, 868, 866, 865, 863, 862,
677 860, 859, 858, 856, 855, 853, 852, 851,
678 849, 848, 846, 845, 844, 842, 841, 840,
679 838, 837, 836, 834, 833, 832, 830, 829,
680 828, 826, 825, 824, 823, 821, 820, 819,
681 817, 816, 815, 814, 812, 811, 810, 809,
682 807, 806, 805, 804, 802, 801, 800, 799,
683 798, 796, 795, 794, 793, 791, 790, 789,
684 788, 787, 786, 784, 783, 782, 781, 780,
685 779, 777, 776, 775, 774, 773, 772, 771,
686 769, 768, 767, 766, 765, 764, 763, 762,
687 760, 759, 758, 757, 756, 755, 754, 753,
688 752, 751, 750, 748, 747, 746, 745, 744,
689 743, 742, 741, 740, 739, 738, 737, 736,
690 735, 734, 733, 732, 731, 730, 729, 728,
691 727, 726, 725, 724, 723, 722, 721, 720,
692 719, 718, 717, 716, 715, 714, 713, 712,
693 711, 710, 709, 708, 707, 706, 705, 704,
694 703, 702, 701, 700, 699, 699, 698, 697,
695 696, 695, 694, 693, 692, 691, 690, 689,
696 688, 688, 687, 686, 685, 684, 683, 682,
697 681, 680, 680, 679, 678, 677, 676, 675,
698 674, 673, 673, 672, 671, 670, 669, 668,
699 667, 667, 666, 665, 664, 663, 662, 661,
700 661, 660, 659, 658, 657, 657, 656, 655,
701 654, 653, 652, 652, 651, 650, 649, 648,
702 648, 647, 646, 645, 644, 644, 643, 642,
703 641, 640, 640, 639, 638, 637, 637, 636,
704 635, 634, 633, 633, 632, 631, 630, 630,
705 629, 628, 627, 627, 626, 625, 624, 624,
706 623, 622, 621, 621, 620, 619, 618, 618,
707 617, 616, 616, 615, 614, 613, 613, 612,
708 611, 611, 610, 609, 608, 608, 607, 606,
709 606, 605, 604, 604, 603, 602, 601, 601,
710 600, 599, 599, 598, 597, 597, 596, 595,
711 595, 594, 593, 593, 592, 591, 591, 590,
712 589, 589, 588, 587, 587, 586, 585, 585,
713 584, 583, 583, 582, 581, 581, 580, 579,
714 579, 578, 578, 577, 576, 576, 575, 574,
715 574, 573, 572, 572, 571, 571, 570, 569,
716 569, 568, 568, 567, 566, 566, 565, 564,
717 564, 563, 563, 562, 561, 561, 560, 560,
718 559, 558, 558, 557, 557, 556, 555, 555,
719 554, 554, 553, 553, 552, 551, 551, 550,
720 550, 549, 548, 548, 547, 547, 546, 546,
721 545, 544, 544, 543, 543, 542, 542, 541,
722 541, 540, 539, 539, 538, 538, 537, 537,
723 536, 536, 535, 534, 534, 533, 533, 532,
724 532, 531, 531, 530, 530, 529, 529, 528,
725 527, 527, 526, 526, 525, 525, 524, 524,
726 523, 523, 522, 522, 521, 521, 520, 520,
727 519, 519, 518, 518, 517, 517, 516, 516,
728 515, 515, 514, 514
729 };
730
731 // Note that LinearToGamma() expects the values to be premultiplied by 4,
732 // so we incorporate this factor 4 inside the DIVIDE_BY_ALPHA macro directly.
733 #define DIVIDE_BY_ALPHA(sum, a) (((sum) * kInvAlpha[(a)]) >> (kAlphaFix - 2))
734
735 #else
736
737 #define DIVIDE_BY_ALPHA(sum, a) (4 * (sum) / (a))
738
739 #endif // USE_INVERSE_ALPHA_TABLE
740
741 static WEBP_INLINE int LinearToGammaWeighted(const uint8_t* src,
742 const uint8_t* a_ptr,
743 uint32_t total_a, int step,
744 int rgb_stride) {
745 const uint32_t sum =
746 a_ptr[0] * GammaToLinear(src[0]) +
747 a_ptr[step] * GammaToLinear(src[step]) +
748 a_ptr[rgb_stride] * GammaToLinear(src[rgb_stride]) +
749 a_ptr[rgb_stride + step] * GammaToLinear(src[rgb_stride + step]);
750 assert(total_a > 0 && total_a <= 4 * 0xff);
751 #if defined(USE_INVERSE_ALPHA_TABLE)
752 assert((uint64_t)sum * kInvAlpha[total_a] < ((uint64_t)1 << 32));
753 #endif
754 return LinearToGamma(DIVIDE_BY_ALPHA(sum, total_a), 0);
755 }
756
757 static WEBP_INLINE void ConvertRowToY(const uint8_t* const r_ptr,
758 const uint8_t* const g_ptr,
759 const uint8_t* const b_ptr,
760 int step,
761 uint8_t* const dst_y,
762 int width,
763 VP8Random* const rg) {
764 int i, j;
765 for (i = 0, j = 0; i < width; ++i, j += step) {
766 dst_y[i] = RGBToY(r_ptr[j], g_ptr[j], b_ptr[j], rg);
767 }
768 }
769
770 static WEBP_INLINE void ConvertRowsToUVWithAlpha(const uint8_t* const r_ptr,
771 const uint8_t* const g_ptr,
772 const uint8_t* const b_ptr,
773 const uint8_t* const a_ptr,
774 int rgb_stride,
775 uint8_t* const dst_u,
776 uint8_t* const dst_v,
777 int width,
778 VP8Random* const rg) {
779 int i, j;
780 // we loop over 2x2 blocks and produce one U/V value for each.
781 for (i = 0, j = 0; i < (width >> 1); ++i, j += 2 * sizeof(uint32_t)) {
782 const uint32_t a = SUM4ALPHA(a_ptr + j);
783 int r, g, b;
784 if (a == 4 * 0xff || a == 0) {
785 r = SUM4(r_ptr + j, 4);
786 g = SUM4(g_ptr + j, 4);
787 b = SUM4(b_ptr + j, 4);
788 } else {
789 r = LinearToGammaWeighted(r_ptr + j, a_ptr + j, a, 4, rgb_stride);
790 g = LinearToGammaWeighted(g_ptr + j, a_ptr + j, a, 4, rgb_stride);
791 b = LinearToGammaWeighted(b_ptr + j, a_ptr + j, a, 4, rgb_stride);
792 }
793 dst_u[i] = RGBToU(r, g, b, rg);
794 dst_v[i] = RGBToV(r, g, b, rg);
795 }
796 if (width & 1) {
797 const uint32_t a = 2u * SUM2ALPHA(a_ptr + j);
798 int r, g, b;
799 if (a == 4 * 0xff || a == 0) {
800 r = SUM2(r_ptr + j);
801 g = SUM2(g_ptr + j);
802 b = SUM2(b_ptr + j);
803 } else {
804 r = LinearToGammaWeighted(r_ptr + j, a_ptr + j, a, 0, rgb_stride);
805 g = LinearToGammaWeighted(g_ptr + j, a_ptr + j, a, 0, rgb_stride);
806 b = LinearToGammaWeighted(b_ptr + j, a_ptr + j, a, 0, rgb_stride);
807 }
808 dst_u[i] = RGBToU(r, g, b, rg);
809 dst_v[i] = RGBToV(r, g, b, rg);
810 }
811 }
812
813 static WEBP_INLINE void ConvertRowsToUV(const uint8_t* const r_ptr,
814 const uint8_t* const g_ptr,
815 const uint8_t* const b_ptr,
816 int step, int rgb_stride,
817 uint8_t* const dst_u,
818 uint8_t* const dst_v,
819 int width,
820 VP8Random* const rg) {
821 int i, j;
822 for (i = 0, j = 0; i < (width >> 1); ++i, j += 2 * step) {
823 const int r = SUM4(r_ptr + j, step);
824 const int g = SUM4(g_ptr + j, step);
825 const int b = SUM4(b_ptr + j, step);
826 dst_u[i] = RGBToU(r, g, b, rg);
827 dst_v[i] = RGBToV(r, g, b, rg);
828 }
829 if (width & 1) {
830 const int r = SUM2(r_ptr + j);
831 const int g = SUM2(g_ptr + j);
832 const int b = SUM2(b_ptr + j);
833 dst_u[i] = RGBToU(r, g, b, rg);
834 dst_v[i] = RGBToV(r, g, b, rg);
835 }
836 }
837
838 static int ImportYUVAFromRGBA(const uint8_t* const r_ptr,
839 const uint8_t* const g_ptr,
840 const uint8_t* const b_ptr,
841 const uint8_t* const a_ptr,
842 int step, // bytes per pixel
843 int rgb_stride, // bytes per scanline
844 float dithering,
845 int use_iterative_conversion,
846 WebPPicture* const picture) {
847 int y;
848 const int width = picture->width;
849 const int height = picture->height;
850 const int has_alpha = CheckNonOpaque(a_ptr, width, height, step, rgb_stride);
851
852 picture->colorspace = has_alpha ? WEBP_YUV420A : WEBP_YUV420;
853 picture->use_argb = 0;
854
855 // disable smart conversion if source is too small (overkill).
856 if (width < kMinDimensionIterativeConversion ||
857 height < kMinDimensionIterativeConversion) {
858 use_iterative_conversion = 0;
859 }
860
861 if (!WebPPictureAllocYUVA(picture, width, height)) {
862 return 0;
863 }
864 if (has_alpha) {
865 WebPInitAlphaProcessing();
866 assert(step == 4);
867 #if defined(USE_INVERSE_ALPHA_TABLE)
868 assert(kAlphaFix + kGammaFix <= 31);
869 #endif
870 }
871
872 if (use_iterative_conversion) {
873 InitGammaTablesF();
874 if (!PreprocessARGB(r_ptr, g_ptr, b_ptr, step, rgb_stride, picture)) {
875 return 0;
876 }
877 if (has_alpha) {
878 WebPExtractAlpha(a_ptr, rgb_stride, width, height,
879 picture->a, picture->a_stride);
880 }
881 } else {
882 uint8_t* dst_y = picture->y;
883 uint8_t* dst_u = picture->u;
884 uint8_t* dst_v = picture->v;
885 uint8_t* dst_a = picture->a;
886
887 VP8Random base_rg;
888 VP8Random* rg = NULL;
889 if (dithering > 0.) {
890 VP8InitRandom(&base_rg, dithering);
891 rg = &base_rg;
892 }
893
894 InitGammaTables();
895
896 // Downsample Y/U/V planes, two rows at a time
897 for (y = 0; y < (height >> 1); ++y) {
898 int rows_have_alpha = has_alpha;
899 const int off1 = (2 * y + 0) * rgb_stride;
900 const int off2 = (2 * y + 1) * rgb_stride;
901 ConvertRowToY(r_ptr + off1, g_ptr + off1, b_ptr + off1, step,
902 dst_y, width, rg);
903 ConvertRowToY(r_ptr + off2, g_ptr + off2, b_ptr + off2, step,
904 dst_y + picture->y_stride, width, rg);
905 dst_y += 2 * picture->y_stride;
906 if (has_alpha) {
907 rows_have_alpha &= !WebPExtractAlpha(a_ptr + off1, rgb_stride,
908 width, 2,
909 dst_a, picture->a_stride);
910 dst_a += 2 * picture->a_stride;
911 }
912 if (!rows_have_alpha) {
913 ConvertRowsToUV(r_ptr + off1, g_ptr + off1, b_ptr + off1,
914 step, rgb_stride, dst_u, dst_v, width, rg);
915 } else {
916 ConvertRowsToUVWithAlpha(r_ptr + off1, g_ptr + off1, b_ptr + off1,
917 a_ptr + off1, rgb_stride,
918 dst_u, dst_v, width, rg);
919 }
920 dst_u += picture->uv_stride;
921 dst_v += picture->uv_stride;
922 }
923 if (height & 1) { // extra last row
924 const int off = 2 * y * rgb_stride;
925 int row_has_alpha = has_alpha;
926 ConvertRowToY(r_ptr + off, g_ptr + off, b_ptr + off, step,
927 dst_y, width, rg);
928 if (row_has_alpha) {
929 row_has_alpha &= !WebPExtractAlpha(a_ptr + off, 0, width, 1, dst_a, 0);
930 }
931 if (!row_has_alpha) {
932 ConvertRowsToUV(r_ptr + off, g_ptr + off, b_ptr + off,
933 step, 0, dst_u, dst_v, width, rg);
934 } else {
935 ConvertRowsToUVWithAlpha(r_ptr + off, g_ptr + off, b_ptr + off,
936 a_ptr + off, 0,
937 dst_u, dst_v, width, rg);
938 }
939 }
940 }
941 return 1;
942 }
943
944 #undef SUM4
945 #undef SUM2
946 #undef SUM4ALPHA
947 #undef SUM2ALPHA
948
949 //------------------------------------------------------------------------------
950 // call for ARGB->YUVA conversion
951
952 static int PictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace,
953 float dithering, int use_iterative_conversion) {
954 if (picture == NULL) return 0;
955 if (picture->argb == NULL) {
956 return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
957 } else if ((colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420) {
958 return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
959 } else {
960 const uint8_t* const argb = (const uint8_t*)picture->argb;
961 const uint8_t* const r = ALPHA_IS_LAST ? argb + 2 : argb + 1;
962 const uint8_t* const g = ALPHA_IS_LAST ? argb + 1 : argb + 2;
963 const uint8_t* const b = ALPHA_IS_LAST ? argb + 0 : argb + 3;
964 const uint8_t* const a = ALPHA_IS_LAST ? argb + 3 : argb + 0;
965
966 picture->colorspace = WEBP_YUV420;
967 return ImportYUVAFromRGBA(r, g, b, a, 4, 4 * picture->argb_stride,
968 dithering, use_iterative_conversion, picture);
969 }
970 }
971
972 int WebPPictureARGBToYUVADithered(WebPPicture* picture, WebPEncCSP colorspace,
973 float dithering) {
974 return PictureARGBToYUVA(picture, colorspace, dithering, 0);
975 }
976
977 int WebPPictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace) {
978 return PictureARGBToYUVA(picture, colorspace, 0.f, 0);
979 }
980
981 #if WEBP_ENCODER_ABI_VERSION > 0x0204
982 int WebPPictureSmartARGBToYUVA(WebPPicture* picture) {
983 return PictureARGBToYUVA(picture, WEBP_YUV420, 0.f, 1);
984 }
985 #endif
986
987 //------------------------------------------------------------------------------
988 // call for YUVA -> ARGB conversion
989
990 int WebPPictureYUVAToARGB(WebPPicture* picture) {
991 if (picture == NULL) return 0;
992 if (picture->y == NULL || picture->u == NULL || picture->v == NULL) {
993 return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
994 }
995 if ((picture->colorspace & WEBP_CSP_ALPHA_BIT) && picture->a == NULL) {
996 return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
997 }
998 if ((picture->colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420) {
999 return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
1000 }
1001 // Allocate a new argb buffer (discarding the previous one).
1002 if (!WebPPictureAllocARGB(picture, picture->width, picture->height)) return 0;
1003 picture->use_argb = 1;
1004
1005 // Convert
1006 {
1007 int y;
1008 const int width = picture->width;
1009 const int height = picture->height;
1010 const int argb_stride = 4 * picture->argb_stride;
1011 uint8_t* dst = (uint8_t*)picture->argb;
1012 const uint8_t *cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
1013 WebPUpsampleLinePairFunc upsample = WebPGetLinePairConverter(ALPHA_IS_LAST);
1014
1015 // First row, with replicated top samples.
1016 upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, width);
1017 cur_y += picture->y_stride;
1018 dst += argb_stride;
1019 // Center rows.
1020 for (y = 1; y + 1 < height; y += 2) {
1021 const uint8_t* const top_u = cur_u;
1022 const uint8_t* const top_v = cur_v;
1023 cur_u += picture->uv_stride;
1024 cur_v += picture->uv_stride;
1025 upsample(cur_y, cur_y + picture->y_stride, top_u, top_v, cur_u, cur_v,
1026 dst, dst + argb_stride, width);
1027 cur_y += 2 * picture->y_stride;
1028 dst += 2 * argb_stride;
1029 }
1030 // Last row (if needed), with replicated bottom samples.
1031 if (height > 1 && !(height & 1)) {
1032 upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, width);
1033 }
1034 // Insert alpha values if needed, in replacement for the default 0xff ones.
1035 if (picture->colorspace & WEBP_CSP_ALPHA_BIT) {
1036 for (y = 0; y < height; ++y) {
1037 uint32_t* const argb_dst = picture->argb + y * picture->argb_stride;
1038 const uint8_t* const src = picture->a + y * picture->a_stride;
1039 int x;
1040 for (x = 0; x < width; ++x) {
1041 argb_dst[x] = (argb_dst[x] & 0x00ffffffu) | ((uint32_t)src[x] << 24);
1042 }
1043 }
1044 }
1045 }
1046 return 1;
1047 }
1048
1049 //------------------------------------------------------------------------------
1050 // automatic import / conversion
1051
1052 static int Import(WebPPicture* const picture,
1053 const uint8_t* const rgb, int rgb_stride,
1054 int step, int swap_rb, int import_alpha) {
1055 int y;
1056 const uint8_t* const r_ptr = rgb + (swap_rb ? 2 : 0);
1057 const uint8_t* const g_ptr = rgb + 1;
1058 const uint8_t* const b_ptr = rgb + (swap_rb ? 0 : 2);
1059 const uint8_t* const a_ptr = import_alpha ? rgb + 3 : NULL;
1060 const int width = picture->width;
1061 const int height = picture->height;
1062
1063 if (!picture->use_argb) {
1064 return ImportYUVAFromRGBA(r_ptr, g_ptr, b_ptr, a_ptr, step, rgb_stride,
1065 0.f /* no dithering */, 0, picture);
1066 }
1067 if (!WebPPictureAlloc(picture)) return 0;
1068
1069 assert(step >= (import_alpha ? 4 : 3));
1070 for (y = 0; y < height; ++y) {
1071 uint32_t* const dst = &picture->argb[y * picture->argb_stride];
1072 int x;
1073 for (x = 0; x < width; ++x) {
1074 const int offset = step * x + y * rgb_stride;
1075 dst[x] = MakeARGB32(import_alpha ? a_ptr[offset] : 0xff,
1076 r_ptr[offset], g_ptr[offset], b_ptr[offset]);
1077 }
1078 }
1079 return 1;
1080 }
1081
1082 // Public API
1083
1084 int WebPPictureImportRGB(WebPPicture* picture,
1085 const uint8_t* rgb, int rgb_stride) {
1086 return (picture != NULL) ? Import(picture, rgb, rgb_stride, 3, 0, 0) : 0;
1087 }
1088
1089 int WebPPictureImportBGR(WebPPicture* picture,
1090 const uint8_t* rgb, int rgb_stride) {
1091 return (picture != NULL) ? Import(picture, rgb, rgb_stride, 3, 1, 0) : 0;
1092 }
1093
1094 int WebPPictureImportRGBA(WebPPicture* picture,
1095 const uint8_t* rgba, int rgba_stride) {
1096 return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 0, 1) : 0;
1097 }
1098
1099 int WebPPictureImportBGRA(WebPPicture* picture,
1100 const uint8_t* rgba, int rgba_stride) {
1101 return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 1, 1) : 0;
1102 }
1103
1104 int WebPPictureImportRGBX(WebPPicture* picture,
1105 const uint8_t* rgba, int rgba_stride) {
1106 return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 0, 0) : 0;
1107 }
1108
1109 int WebPPictureImportBGRX(WebPPicture* picture,
1110 const uint8_t* rgba, int rgba_stride) {
1111 return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 1, 0) : 0;
1112 }
1113
1114 //------------------------------------------------------------------------------