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 (at) 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 //------------------------------------------------------------------------------ 1115
