third_party/libwebp/enc/picture_csp.c

   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 "../dsp/yuv.h"
  21
  22 // Uncomment to disable gamma-compression during RGB->U/V averaging
  23 #define USE_GAMMA_COMPRESSION
  24
  25 static const union {
  26   uint32_t argb;
  27   uint8_t  bytes[4];
  28 } test_endian = { 0xff000000u };
  29 #define ALPHA_IS_LAST (test_endian.bytes[3] == 0xff)
  30
  31 static WEBP_INLINE uint32_t MakeARGB32(int a, int r, int g, int b) {
  32   return (((uint32_t)a << 24) | (r << 16) | (g << 8) | b);
  33 }
  34
  35 //------------------------------------------------------------------------------
  36 // Detection of non-trivial transparency
  37
  38 // Returns true if alpha[] has non-0xff values.
  39 static int CheckNonOpaque(const uint8_t* alpha, int width, int height,
  40                           int x_step, int y_step) {
  41   if (alpha == NULL) return 0;
  42   while (height-- > 0) {
  43     int x;
  44     for (x = 0; x < width * x_step; x += x_step) {
  45       if (alpha[x] != 0xff) return 1;  // TODO(skal): check 4/8 bytes at a time.
  46     }
  47     alpha += y_step;
  48   }
  49   return 0;
  50 }
  51
  52 // Checking for the presence of non-opaque alpha.
  53 int WebPPictureHasTransparency(const WebPPicture* picture) {
  54   if (picture == NULL) return 0;
  55   if (!picture->use_argb) {
  56     return CheckNonOpaque(picture->a, picture->width, picture->height,
  57                           1, picture->a_stride);
  58   } else {
  59     int x, y;
  60     const uint32_t* argb = picture->argb;
  61     if (argb == NULL) return 0;
  62     for (y = 0; y < picture->height; ++y) {
  63       for (x = 0; x < picture->width; ++x) {
  64         if (argb[x] < 0xff000000u) return 1;   // test any alpha values != 0xff
  65       }
  66       argb += picture->argb_stride;
  67     }
  68   }
  69   return 0;
  70 }
  71
  72 //------------------------------------------------------------------------------
  73 // RGB -> YUV conversion
  74
  75 static int RGBToY(int r, int g, int b, VP8Random* const rg) {
  76   return VP8RGBToY(r, g, b, VP8RandomBits(rg, YUV_FIX));
  77 }
  78
  79 static int RGBToU(int r, int g, int b, VP8Random* const rg) {
  80   return VP8RGBToU(r, g, b, VP8RandomBits(rg, YUV_FIX + 2));
  81 }
  82
  83 static int RGBToV(int r, int g, int b, VP8Random* const rg) {
  84   return VP8RGBToV(r, g, b, VP8RandomBits(rg, YUV_FIX + 2));
  85 }
  86
  87 //------------------------------------------------------------------------------
  88
  89 #if defined(USE_GAMMA_COMPRESSION)
  90
  91 // gamma-compensates loss of resolution during chroma subsampling
  92 #define kGamma 0.80
  93 #define kGammaFix 12     // fixed-point precision for linear values
  94 #define kGammaScale ((1 << kGammaFix) - 1)
  95 #define kGammaTabFix 7   // fixed-point fractional bits precision
  96 #define kGammaTabScale (1 << kGammaTabFix)
  97 #define kGammaTabRounder (kGammaTabScale >> 1)
  98 #define kGammaTabSize (1 << (kGammaFix - kGammaTabFix))
  99
 100 static int kLinearToGammaTab[kGammaTabSize + 1];
 101 static uint16_t kGammaToLinearTab[256];
 102 static int kGammaTablesOk = 0;
 103
 104 static void InitGammaTables(void) {
 105   if (!kGammaTablesOk) {
 106     int v;
 107     const double scale = 1. / kGammaScale;
 108     for (v = 0; v <= 255; ++v) {
 109       kGammaToLinearTab[v] =
 110           (uint16_t)(pow(v / 255., kGamma) * kGammaScale + .5);
 111     }
 112     for (v = 0; v <= kGammaTabSize; ++v) {
 113       const double x = scale * (v << kGammaTabFix);
 114       kLinearToGammaTab[v] = (int)(pow(x, 1. / kGamma) * 255. + .5);
 115     }
 116     kGammaTablesOk = 1;
 117   }
 118 }
 119
 120 static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) {
 121   return kGammaToLinearTab[v];
 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 v = base_value << shift;              // final uplifted value
 128   const int tab_pos = v >> (kGammaTabFix + 2);    // integer part
 129   const int x = v & ((kGammaTabScale << 2) - 1);  // fractional part
 130   const int v0 = kLinearToGammaTab[tab_pos];
 131   const int v1 = kLinearToGammaTab[tab_pos + 1];
 132   const int y = v1 * x + v0 * ((kGammaTabScale << 2) - x);   // interpolate
 133   return (y + kGammaTabRounder) >> kGammaTabFix;             // descale
 134 }
 135
 136 #else
 137
 138 static void InitGammaTables(void) {}
 139 static WEBP_INLINE uint32_t GammaToLinear(uint8_t v) { return v; }
 140 static WEBP_INLINE int LinearToGamma(uint32_t base_value, int shift) {
 141   return (int)(base_value << shift);
 142 }
 143
 144 #endif    // USE_GAMMA_COMPRESSION
 145
 146 //------------------------------------------------------------------------------
 147
 148 #define SUM4(ptr) LinearToGamma(                         \
 149     GammaToLinear((ptr)[0]) +                            \
 150     GammaToLinear((ptr)[step]) +                         \
 151     GammaToLinear((ptr)[rgb_stride]) +                   \
 152     GammaToLinear((ptr)[rgb_stride + step]), 0)          \
 153
 154 #define SUM2H(ptr) \
 155     LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[step]), 1)
 156 #define SUM2V(ptr) \
 157     LinearToGamma(GammaToLinear((ptr)[0]) + GammaToLinear((ptr)[rgb_stride]), 1)
 158 #define SUM1(ptr)  \
 159     LinearToGamma(GammaToLinear((ptr)[0]), 2)
 160
 161 #define RGB_TO_UV(x, y, SUM) {                           \
 162   const int src = (2 * (step * (x) + (y) * rgb_stride)); \
 163   const int dst = (x) + (y) * picture->uv_stride;        \
 164   const int r = SUM(r_ptr + src);                        \
 165   const int g = SUM(g_ptr + src);                        \
 166   const int b = SUM(b_ptr + src);                        \
 167   picture->u[dst] = RGBToU(r, g, b, &rg);                \
 168   picture->v[dst] = RGBToV(r, g, b, &rg);                \
 169 }
 170
 171 static int ImportYUVAFromRGBA(const uint8_t* const r_ptr,
 172                               const uint8_t* const g_ptr,
 173                               const uint8_t* const b_ptr,
 174                               const uint8_t* const a_ptr,
 175                               int step,         // bytes per pixel
 176                               int rgb_stride,   // bytes per scanline
 177                               float dithering,
 178                               WebPPicture* const picture) {
 179   int x, y;
 180   const int width = picture->width;
 181   const int height = picture->height;
 182   const int has_alpha = CheckNonOpaque(a_ptr, width, height, step, rgb_stride);
 183   VP8Random rg;
 184
 185   if (has_alpha) {
 186     picture->colorspace |= WEBP_CSP_ALPHA_BIT;
 187   } else {
 188     picture->colorspace &= WEBP_CSP_UV_MASK;
 189   }
 190   picture->use_argb = 0;
 191
 192   if (!WebPPictureAllocYUVA(picture, width, height)) return 0;
 193
 194   VP8InitRandom(&rg, dithering);
 195   InitGammaTables();
 196
 197   // Import luma plane
 198   for (y = 0; y < height; ++y) {
 199     uint8_t* const dst = &picture->y[y * picture->y_stride];
 200     for (x = 0; x < width; ++x) {
 201       const int offset = step * x + y * rgb_stride;
 202       dst[x] = RGBToY(r_ptr[offset], g_ptr[offset], b_ptr[offset], &rg);
 203     }
 204   }
 205
 206   // Downsample U/V plane
 207   for (y = 0; y < (height >> 1); ++y) {
 208     for (x = 0; x < (width >> 1); ++x) {
 209       RGB_TO_UV(x, y, SUM4);
 210     }
 211     if (width & 1) {
 212       RGB_TO_UV(x, y, SUM2V);
 213     }
 214   }
 215   if (height & 1) {
 216     for (x = 0; x < (width >> 1); ++x) {
 217       RGB_TO_UV(x, y, SUM2H);
 218     }
 219     if (width & 1) {
 220       RGB_TO_UV(x, y, SUM1);
 221     }
 222   }
 223
 224   if (has_alpha) {
 225     assert(step >= 4);
 226     assert(picture->a != NULL);
 227     for (y = 0; y < height; ++y) {
 228       for (x = 0; x < width; ++x) {
 229         picture->a[x + y * picture->a_stride] =
 230             a_ptr[step * x + y * rgb_stride];
 231       }
 232     }
 233   }
 234   return 1;
 235 }
 236
 237 #undef SUM4
 238 #undef SUM2V
 239 #undef SUM2H
 240 #undef SUM1
 241 #undef RGB_TO_UV
 242
 243 //------------------------------------------------------------------------------
 244 // call for ARGB->YUVA conversion
 245
 246 int WebPPictureARGBToYUVADithered(WebPPicture* picture, WebPEncCSP colorspace,
 247                                   float dithering) {
 248   if (picture == NULL) return 0;
 249   if (picture->argb == NULL) {
 250     return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
 251   } else {
 252     const uint8_t* const argb = (const uint8_t*)picture->argb;
 253     const uint8_t* const r = ALPHA_IS_LAST ? argb + 2 : argb + 1;
 254     const uint8_t* const g = ALPHA_IS_LAST ? argb + 1 : argb + 2;
 255     const uint8_t* const b = ALPHA_IS_LAST ? argb + 0 : argb + 3;
 256     const uint8_t* const a = ALPHA_IS_LAST ? argb + 3 : argb + 0;
 257
 258     picture->colorspace = colorspace;
 259     return ImportYUVAFromRGBA(r, g, b, a, 4, 4 * picture->argb_stride,
 260                               dithering, picture);
 261   }
 262 }
 263
 264 int WebPPictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace) {
 265   return WebPPictureARGBToYUVADithered(picture, colorspace, 0.f);
 266 }
 267
 268 //------------------------------------------------------------------------------
 269 // call for YUVA -> ARGB conversion
 270
 271 int WebPPictureYUVAToARGB(WebPPicture* picture) {
 272   if (picture == NULL) return 0;
 273   if (picture->y == NULL || picture->u == NULL || picture->v == NULL) {
 274     return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
 275   }
 276   if ((picture->colorspace & WEBP_CSP_ALPHA_BIT) && picture->a == NULL) {
 277     return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
 278   }
 279   if ((picture->colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420) {
 280     return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
 281   }
 282   // Allocate a new argb buffer (discarding the previous one).
 283   if (!WebPPictureAllocARGB(picture, picture->width, picture->height)) return 0;
 284   picture->use_argb = 1;
 285
 286   // Convert
 287   {
 288     int y;
 289     const int width = picture->width;
 290     const int height = picture->height;
 291     const int argb_stride = 4 * picture->argb_stride;
 292     uint8_t* dst = (uint8_t*)picture->argb;
 293     const uint8_t *cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
 294     WebPUpsampleLinePairFunc upsample = WebPGetLinePairConverter(ALPHA_IS_LAST);
 295
 296     // First row, with replicated top samples.
 297     upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, width);
 298     cur_y += picture->y_stride;
 299     dst += argb_stride;
 300     // Center rows.
 301     for (y = 1; y + 1 < height; y += 2) {
 302       const uint8_t* const top_u = cur_u;
 303       const uint8_t* const top_v = cur_v;
 304       cur_u += picture->uv_stride;
 305       cur_v += picture->uv_stride;
 306       upsample(cur_y, cur_y + picture->y_stride, top_u, top_v, cur_u, cur_v,
 307                dst, dst + argb_stride, width);
 308       cur_y += 2 * picture->y_stride;
 309       dst += 2 * argb_stride;
 310     }
 311     // Last row (if needed), with replicated bottom samples.
 312     if (height > 1 && !(height & 1)) {
 313       upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, width);
 314     }
 315     // Insert alpha values if needed, in replacement for the default 0xff ones.
 316     if (picture->colorspace & WEBP_CSP_ALPHA_BIT) {
 317       for (y = 0; y < height; ++y) {
 318         uint32_t* const argb_dst = picture->argb + y * picture->argb_stride;
 319         const uint8_t* const src = picture->a + y * picture->a_stride;
 320         int x;
 321         for (x = 0; x < width; ++x) {
 322           argb_dst[x] = (argb_dst[x] & 0x00ffffffu) | ((uint32_t)src[x] << 24);
 323         }
 324       }
 325     }
 326   }
 327   return 1;
 328 }
 329
 330 //------------------------------------------------------------------------------
 331 // automatic import / conversion
 332
 333 static int Import(WebPPicture* const picture,
 334                   const uint8_t* const rgb, int rgb_stride,
 335                   int step, int swap_rb, int import_alpha) {
 336   int y;
 337   const uint8_t* const r_ptr = rgb + (swap_rb ? 2 : 0);
 338   const uint8_t* const g_ptr = rgb + 1;
 339   const uint8_t* const b_ptr = rgb + (swap_rb ? 0 : 2);
 340   const uint8_t* const a_ptr = import_alpha ? rgb + 3 : NULL;
 341   const int width = picture->width;
 342   const int height = picture->height;
 343
 344   if (!picture->use_argb) {
 345     return ImportYUVAFromRGBA(r_ptr, g_ptr, b_ptr, a_ptr, step, rgb_stride,
 346                               0.f /* no dithering */, picture);
 347   }
 348   if (!WebPPictureAlloc(picture)) return 0;
 349
 350   assert(step >= (import_alpha ? 4 : 3));
 351   for (y = 0; y < height; ++y) {
 352     uint32_t* const dst = &picture->argb[y * picture->argb_stride];
 353     int x;
 354     for (x = 0; x < width; ++x) {
 355       const int offset = step * x + y * rgb_stride;
 356       dst[x] = MakeARGB32(import_alpha ? a_ptr[offset] : 0xff,
 357                           r_ptr[offset], g_ptr[offset], b_ptr[offset]);
 358     }
 359   }
 360   return 1;
 361 }
 362
 363 // Public API
 364
 365 int WebPPictureImportRGB(WebPPicture* picture,
 366                          const uint8_t* rgb, int rgb_stride) {
 367   return (picture != NULL) ? Import(picture, rgb, rgb_stride, 3, 0, 0) : 0;
 368 }
 369
 370 int WebPPictureImportBGR(WebPPicture* picture,
 371                          const uint8_t* rgb, int rgb_stride) {
 372   return (picture != NULL) ? Import(picture, rgb, rgb_stride, 3, 1, 0) : 0;
 373 }
 374
 375 int WebPPictureImportRGBA(WebPPicture* picture,
 376                           const uint8_t* rgba, int rgba_stride) {
 377   return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 0, 1) : 0;
 378 }
 379
 380 int WebPPictureImportBGRA(WebPPicture* picture,
 381                           const uint8_t* rgba, int rgba_stride) {
 382   return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 1, 1) : 0;
 383 }
 384
 385 int WebPPictureImportRGBX(WebPPicture* picture,
 386                           const uint8_t* rgba, int rgba_stride) {
 387   return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 0, 0) : 0;
 388 }
 389
 390 int WebPPictureImportBGRX(WebPPicture* picture,
 391                           const uint8_t* rgba, int rgba_stride) {
 392   return (picture != NULL) ? Import(picture, rgba, rgba_stride, 4, 1, 0) : 0;
 393 }
 394
 395 //------------------------------------------------------------------------------