src/SDL2/external/libwebp-0.3.0/src/dsp/upsampling.c

   1 // Copyright 2011 Google Inc. All Rights Reserved.
   2 //
   3 // This code is licensed under the same terms as WebM:
   4 //  Software License Agreement:  http://www.webmproject.org/license/software/
   5 //  Additional IP Rights Grant:  http://www.webmproject.org/license/additional/
   6 // -----------------------------------------------------------------------------
   7 //
   8 // YUV to RGB upsampling functions.
   9 //
  10 // Author: somnath@google.com (Somnath Banerjee)
  11
  12 #include "./dsp.h"
  13 #include "./yuv.h"
  14
  15 #if defined(__cplusplus) || defined(c_plusplus)
  16 extern "C" {
  17 #endif
  18
  19 //------------------------------------------------------------------------------
  20 // Fancy upsampler
  21
  22 #ifdef FANCY_UPSAMPLING
  23
  24 // Fancy upsampling functions to convert YUV to RGB
  25 WebPUpsampleLinePairFunc WebPUpsamplers[MODE_LAST];
  26
  27 // Given samples laid out in a square as:
  28 //  [a b]
  29 //  [c d]
  30 // we interpolate u/v as:
  31 //  ([9*a + 3*b + 3*c +   d    3*a + 9*b + 3*c +   d] + [8 8]) / 16
  32 //  ([3*a +   b + 9*c + 3*d      a + 3*b + 3*c + 9*d]   [8 8]) / 16
  33
  34 // We process u and v together stashed into 32bit (16bit each).
  35 #define LOAD_UV(u, v) ((u) | ((v) << 16))
  36
  37 #define UPSAMPLE_FUNC(FUNC_NAME, FUNC, XSTEP)                                  \
  38 static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bottom_y,           \
  39                       const uint8_t* top_u, const uint8_t* top_v,              \
  40                       const uint8_t* cur_u, const uint8_t* cur_v,              \
  41                       uint8_t* top_dst, uint8_t* bottom_dst, int len) {        \
  42   int x;                                                                       \
  43   const int last_pixel_pair = (len - 1) >> 1;                                  \
  44   uint32_t tl_uv = LOAD_UV(top_u[0], top_v[0]);   /* top-left sample */        \
  45   uint32_t l_uv  = LOAD_UV(cur_u[0], cur_v[0]);   /* left-sample */            \
  46   if (top_y) {                                                                 \
  47     const uint32_t uv0 = (3 * tl_uv + l_uv + 0x00020002u) >> 2;                \
  48     FUNC(top_y[0], uv0 & 0xff, (uv0 >> 16), top_dst);                          \
  49   }                                                                            \
  50   if (bottom_y) {                                                              \
  51     const uint32_t uv0 = (3 * l_uv + tl_uv + 0x00020002u) >> 2;                \
  52     FUNC(bottom_y[0], uv0 & 0xff, (uv0 >> 16), bottom_dst);                    \
  53   }                                                                            \
  54   for (x = 1; x <= last_pixel_pair; ++x) {                                     \
  55     const uint32_t t_uv = LOAD_UV(top_u[x], top_v[x]);  /* top sample */       \
  56     const uint32_t uv   = LOAD_UV(cur_u[x], cur_v[x]);  /* sample */           \
  57     /* precompute invariant values associated with first and second diagonals*/\
  58     const uint32_t avg = tl_uv + t_uv + l_uv + uv + 0x00080008u;               \
  59     const uint32_t diag_12 = (avg + 2 * (t_uv + l_uv)) >> 3;                   \
  60     const uint32_t diag_03 = (avg + 2 * (tl_uv + uv)) >> 3;                    \
  61     if (top_y) {                                                               \
  62       const uint32_t uv0 = (diag_12 + tl_uv) >> 1;                             \
  63       const uint32_t uv1 = (diag_03 + t_uv) >> 1;                              \
  64       FUNC(top_y[2 * x - 1], uv0 & 0xff, (uv0 >> 16),                          \
  65            top_dst + (2 * x - 1) * XSTEP);                                     \
  66       FUNC(top_y[2 * x - 0], uv1 & 0xff, (uv1 >> 16),                          \
  67            top_dst + (2 * x - 0) * XSTEP);                                     \
  68     }                                                                          \
  69     if (bottom_y) {                                                            \
  70       const uint32_t uv0 = (diag_03 + l_uv) >> 1;                              \
  71       const uint32_t uv1 = (diag_12 + uv) >> 1;                                \
  72       FUNC(bottom_y[2 * x - 1], uv0 & 0xff, (uv0 >> 16),                       \
  73            bottom_dst + (2 * x - 1) * XSTEP);                                  \
  74       FUNC(bottom_y[2 * x + 0], uv1 & 0xff, (uv1 >> 16),                       \
  75            bottom_dst + (2 * x + 0) * XSTEP);                                  \
  76     }                                                                          \
  77     tl_uv = t_uv;                                                              \
  78     l_uv = uv;                                                                 \
  79   }                                                                            \
  80   if (!(len & 1)) {                                                            \
  81     if (top_y) {                                                               \
  82       const uint32_t uv0 = (3 * tl_uv + l_uv + 0x00020002u) >> 2;              \
  83       FUNC(top_y[len - 1], uv0 & 0xff, (uv0 >> 16),                            \
  84            top_dst + (len - 1) * XSTEP);                                       \
  85     }                                                                          \
  86     if (bottom_y) {                                                            \
  87       const uint32_t uv0 = (3 * l_uv + tl_uv + 0x00020002u) >> 2;              \
  88       FUNC(bottom_y[len - 1], uv0 & 0xff, (uv0 >> 16),                         \
  89            bottom_dst + (len - 1) * XSTEP);                                    \
  90     }                                                                          \
  91   }                                                                            \
  92 }
  93
  94 // All variants implemented.
  95 UPSAMPLE_FUNC(UpsampleRgbLinePair,  VP8YuvToRgb,  3)
  96 UPSAMPLE_FUNC(UpsampleBgrLinePair,  VP8YuvToBgr,  3)
  97 UPSAMPLE_FUNC(UpsampleRgbaLinePair, VP8YuvToRgba, 4)
  98 UPSAMPLE_FUNC(UpsampleBgraLinePair, VP8YuvToBgra, 4)
  99 UPSAMPLE_FUNC(UpsampleArgbLinePair, VP8YuvToArgb, 4)
 100 UPSAMPLE_FUNC(UpsampleRgba4444LinePair, VP8YuvToRgba4444, 2)
 101 UPSAMPLE_FUNC(UpsampleRgb565LinePair,  VP8YuvToRgb565,  2)
 102
 103 #undef LOAD_UV
 104 #undef UPSAMPLE_FUNC
 105
 106 #endif  // FANCY_UPSAMPLING
 107
 108 //------------------------------------------------------------------------------
 109 // simple point-sampling
 110
 111 #define SAMPLE_FUNC(FUNC_NAME, FUNC, XSTEP)                                    \
 112 static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bottom_y,           \
 113                       const uint8_t* u, const uint8_t* v,                      \
 114                       uint8_t* top_dst, uint8_t* bottom_dst, int len) {        \
 115   int i;                                                                       \
 116   for (i = 0; i < len - 1; i += 2) {                                           \
 117     FUNC(top_y[0], u[0], v[0], top_dst);                                       \
 118     FUNC(top_y[1], u[0], v[0], top_dst + XSTEP);                               \
 119     FUNC(bottom_y[0], u[0], v[0], bottom_dst);                                 \
 120     FUNC(bottom_y[1], u[0], v[0], bottom_dst + XSTEP);                         \
 121     top_y += 2;                                                                \
 122     bottom_y += 2;                                                             \
 123     u++;                                                                       \
 124     v++;                                                                       \
 125     top_dst += 2 * XSTEP;                                                      \
 126     bottom_dst += 2 * XSTEP;                                                   \
 127   }                                                                            \
 128   if (i == len - 1) {    /* last one */                                        \
 129     FUNC(top_y[0], u[0], v[0], top_dst);                                       \
 130     FUNC(bottom_y[0], u[0], v[0], bottom_dst);                                 \
 131   }                                                                            \
 132 }
 133
 134 // All variants implemented.
 135 SAMPLE_FUNC(SampleRgbLinePair,      VP8YuvToRgb,  3)
 136 SAMPLE_FUNC(SampleBgrLinePair,      VP8YuvToBgr,  3)
 137 SAMPLE_FUNC(SampleRgbaLinePair,     VP8YuvToRgba, 4)
 138 SAMPLE_FUNC(SampleBgraLinePair,     VP8YuvToBgra, 4)
 139 SAMPLE_FUNC(SampleArgbLinePair,     VP8YuvToArgb, 4)
 140 SAMPLE_FUNC(SampleRgba4444LinePair, VP8YuvToRgba4444, 2)
 141 SAMPLE_FUNC(SampleRgb565LinePair,   VP8YuvToRgb565, 2)
 142
 143 #undef SAMPLE_FUNC
 144
 145 const WebPSampleLinePairFunc WebPSamplers[MODE_LAST] = {
 146   SampleRgbLinePair,       // MODE_RGB
 147   SampleRgbaLinePair,      // MODE_RGBA
 148   SampleBgrLinePair,       // MODE_BGR
 149   SampleBgraLinePair,      // MODE_BGRA
 150   SampleArgbLinePair,      // MODE_ARGB
 151   SampleRgba4444LinePair,  // MODE_RGBA_4444
 152   SampleRgb565LinePair,    // MODE_RGB_565
 153   SampleRgbaLinePair,      // MODE_rgbA
 154   SampleBgraLinePair,      // MODE_bgrA
 155   SampleArgbLinePair,      // MODE_Argb
 156   SampleRgba4444LinePair   // MODE_rgbA_4444
 157 };
 158
 159 //------------------------------------------------------------------------------
 160
 161 #if !defined(FANCY_UPSAMPLING)
 162 #define DUAL_SAMPLE_FUNC(FUNC_NAME, FUNC)                                      \
 163 static void FUNC_NAME(const uint8_t* top_y, const uint8_t* bot_y,              \
 164                       const uint8_t* top_u, const uint8_t* top_v,              \
 165                       const uint8_t* bot_u, const uint8_t* bot_v,              \
 166                       uint8_t* top_dst, uint8_t* bot_dst, int len) {           \
 167   const int half_len = len >> 1;                                               \
 168   int x;                                                                       \
 169   if (top_dst != NULL) {                                                       \
 170     for (x = 0; x < half_len; ++x) {                                           \
 171       FUNC(top_y[2 * x + 0], top_u[x], top_v[x], top_dst + 8 * x + 0);         \
 172       FUNC(top_y[2 * x + 1], top_u[x], top_v[x], top_dst + 8 * x + 4);         \
 173     }                                                                          \
 174     if (len & 1) FUNC(top_y[2 * x + 0], top_u[x], top_v[x], top_dst + 8 * x);  \
 175   }                                                                            \
 176   if (bot_dst != NULL) {                                                       \
 177     for (x = 0; x < half_len; ++x) {                                           \
 178       FUNC(bot_y[2 * x + 0], bot_u[x], bot_v[x], bot_dst + 8 * x + 0);         \
 179       FUNC(bot_y[2 * x + 1], bot_u[x], bot_v[x], bot_dst + 8 * x + 4);         \
 180     }                                                                          \
 181     if (len & 1) FUNC(bot_y[2 * x + 0], bot_u[x], bot_v[x], bot_dst + 8 * x);  \
 182   }                                                                            \
 183 }
 184
 185 DUAL_SAMPLE_FUNC(DualLineSamplerBGRA, VP8YuvToBgra)
 186 DUAL_SAMPLE_FUNC(DualLineSamplerARGB, VP8YuvToArgb)
 187 #undef DUAL_SAMPLE_FUNC
 188
 189 #endif  // !FANCY_UPSAMPLING
 190
 191 WebPUpsampleLinePairFunc WebPGetLinePairConverter(int alpha_is_last) {
 192   WebPInitUpsamplers();
 193   VP8YUVInit();
 194 #ifdef FANCY_UPSAMPLING
 195   return WebPUpsamplers[alpha_is_last ? MODE_BGRA : MODE_ARGB];
 196 #else
 197   return (alpha_is_last ? DualLineSamplerBGRA : DualLineSamplerARGB);
 198 #endif
 199 }
 200
 201 //------------------------------------------------------------------------------
 202 // YUV444 converter
 203
 204 #define YUV444_FUNC(FUNC_NAME, FUNC, XSTEP)                                    \
 205 static void FUNC_NAME(const uint8_t* y, const uint8_t* u, const uint8_t* v,    \
 206                       uint8_t* dst, int len) {                                 \
 207   int i;                                                                       \
 208   for (i = 0; i < len; ++i) FUNC(y[i], u[i], v[i], &dst[i * XSTEP]);           \
 209 }
 210
 211 YUV444_FUNC(Yuv444ToRgb,      VP8YuvToRgb,  3)
 212 YUV444_FUNC(Yuv444ToBgr,      VP8YuvToBgr,  3)
 213 YUV444_FUNC(Yuv444ToRgba,     VP8YuvToRgba, 4)
 214 YUV444_FUNC(Yuv444ToBgra,     VP8YuvToBgra, 4)
 215 YUV444_FUNC(Yuv444ToArgb,     VP8YuvToArgb, 4)
 216 YUV444_FUNC(Yuv444ToRgba4444, VP8YuvToRgba4444, 2)
 217 YUV444_FUNC(Yuv444ToRgb565,   VP8YuvToRgb565, 2)
 218
 219 #undef YUV444_FUNC
 220
 221 const WebPYUV444Converter WebPYUV444Converters[MODE_LAST] = {
 222   Yuv444ToRgb,       // MODE_RGB
 223   Yuv444ToRgba,      // MODE_RGBA
 224   Yuv444ToBgr,       // MODE_BGR
 225   Yuv444ToBgra,      // MODE_BGRA
 226   Yuv444ToArgb,      // MODE_ARGB
 227   Yuv444ToRgba4444,  // MODE_RGBA_4444
 228   Yuv444ToRgb565,    // MODE_RGB_565
 229   Yuv444ToRgba,      // MODE_rgbA
 230   Yuv444ToBgra,      // MODE_bgrA
 231   Yuv444ToArgb,      // MODE_Argb
 232   Yuv444ToRgba4444   // MODE_rgbA_4444
 233 };
 234
 235 //------------------------------------------------------------------------------
 236 // Premultiplied modes
 237
 238 // non dithered-modes
 239
 240 // (x * a * 32897) >> 23 is bit-wise equivalent to (int)(x * a / 255.)
 241 // for all 8bit x or a. For bit-wise equivalence to (int)(x * a / 255. + .5),
 242 // one can use instead: (x * a * 65793 + (1 << 23)) >> 24
 243 #if 1     // (int)(x * a / 255.)
 244 #define MULTIPLIER(a)   ((a) * 32897UL)
 245 #define PREMULTIPLY(x, m) (((x) * (m)) >> 23)
 246 #else     // (int)(x * a / 255. + .5)
 247 #define MULTIPLIER(a) ((a) * 65793UL)
 248 #define PREMULTIPLY(x, m) (((x) * (m) + (1UL << 23)) >> 24)
 249 #endif
 250
 251 static void ApplyAlphaMultiply(uint8_t* rgba, int alpha_first,
 252                                int w, int h, int stride) {
 253   while (h-- > 0) {
 254     uint8_t* const rgb = rgba + (alpha_first ? 1 : 0);
 255     const uint8_t* const alpha = rgba + (alpha_first ? 0 : 3);
 256     int i;
 257     for (i = 0; i < w; ++i) {
 258       const uint32_t a = alpha[4 * i];
 259       if (a != 0xff) {
 260         const uint32_t mult = MULTIPLIER(a);
 261         rgb[4 * i + 0] = PREMULTIPLY(rgb[4 * i + 0], mult);
 262         rgb[4 * i + 1] = PREMULTIPLY(rgb[4 * i + 1], mult);
 263         rgb[4 * i + 2] = PREMULTIPLY(rgb[4 * i + 2], mult);
 264       }
 265     }
 266     rgba += stride;
 267   }
 268 }
 269 #undef MULTIPLIER
 270 #undef PREMULTIPLY
 271
 272 // rgbA4444
 273
 274 #define MULTIPLIER(a)  ((a) * 0x1111)    // 0x1111 ~= (1 << 16) / 15
 275
 276 static WEBP_INLINE uint8_t dither_hi(uint8_t x) {
 277   return (x & 0xf0) | (x >> 4);
 278 }
 279
 280 static WEBP_INLINE uint8_t dither_lo(uint8_t x) {
 281   return (x & 0x0f) | (x << 4);
 282 }
 283
 284 static WEBP_INLINE uint8_t multiply(uint8_t x, uint32_t m) {
 285   return (x * m) >> 16;
 286 }
 287
 288 static void ApplyAlphaMultiply4444(uint8_t* rgba4444,
 289                                    int w, int h, int stride) {
 290   while (h-- > 0) {
 291     int i;
 292     for (i = 0; i < w; ++i) {
 293       const uint8_t a = (rgba4444[2 * i + 1] & 0x0f);
 294       const uint32_t mult = MULTIPLIER(a);
 295       const uint8_t r = multiply(dither_hi(rgba4444[2 * i + 0]), mult);
 296       const uint8_t g = multiply(dither_lo(rgba4444[2 * i + 0]), mult);
 297       const uint8_t b = multiply(dither_hi(rgba4444[2 * i + 1]), mult);
 298       rgba4444[2 * i + 0] = (r & 0xf0) | ((g >> 4) & 0x0f);
 299       rgba4444[2 * i + 1] = (b & 0xf0) | a;
 300     }
 301     rgba4444 += stride;
 302   }
 303 }
 304 #undef MULTIPLIER
 305
 306 void (*WebPApplyAlphaMultiply)(uint8_t*, int, int, int, int)
 307     = ApplyAlphaMultiply;
 308 void (*WebPApplyAlphaMultiply4444)(uint8_t*, int, int, int)
 309     = ApplyAlphaMultiply4444;
 310
 311 //------------------------------------------------------------------------------
 312 // Main call
 313
 314 void WebPInitUpsamplers(void) {
 315 #ifdef FANCY_UPSAMPLING
 316   WebPUpsamplers[MODE_RGB]       = UpsampleRgbLinePair;
 317   WebPUpsamplers[MODE_RGBA]      = UpsampleRgbaLinePair;
 318   WebPUpsamplers[MODE_BGR]       = UpsampleBgrLinePair;
 319   WebPUpsamplers[MODE_BGRA]      = UpsampleBgraLinePair;
 320   WebPUpsamplers[MODE_ARGB]      = UpsampleArgbLinePair;
 321   WebPUpsamplers[MODE_RGBA_4444] = UpsampleRgba4444LinePair;
 322   WebPUpsamplers[MODE_RGB_565]   = UpsampleRgb565LinePair;
 323
 324   // If defined, use CPUInfo() to overwrite some pointers with faster versions.
 325   if (VP8GetCPUInfo != NULL) {
 326 #if defined(WEBP_USE_SSE2)
 327     if (VP8GetCPUInfo(kSSE2)) {
 328       WebPInitUpsamplersSSE2();
 329     }
 330 #endif
 331 #if defined(WEBP_USE_NEON)
 332     if (VP8GetCPUInfo(kNEON)) {
 333       WebPInitUpsamplersNEON();
 334     }
 335 #endif
 336   }
 337 #endif  // FANCY_UPSAMPLING
 338 }
 339
 340 void WebPInitPremultiply(void) {
 341   WebPApplyAlphaMultiply = ApplyAlphaMultiply;
 342   WebPApplyAlphaMultiply4444 = ApplyAlphaMultiply4444;
 343
 344 #ifdef FANCY_UPSAMPLING
 345   WebPUpsamplers[MODE_rgbA]      = UpsampleRgbaLinePair;
 346   WebPUpsamplers[MODE_bgrA]      = UpsampleBgraLinePair;
 347   WebPUpsamplers[MODE_Argb]      = UpsampleArgbLinePair;
 348   WebPUpsamplers[MODE_rgbA_4444] = UpsampleRgba4444LinePair;
 349
 350   if (VP8GetCPUInfo != NULL) {
 351 #if defined(WEBP_USE_SSE2)
 352     if (VP8GetCPUInfo(kSSE2)) {
 353       WebPInitPremultiplySSE2();
 354     }
 355 #endif
 356 #if defined(WEBP_USE_NEON)
 357     if (VP8GetCPUInfo(kNEON)) {
 358       WebPInitPremultiplyNEON();
 359     }
 360 #endif
 361   }
 362 #endif  // FANCY_UPSAMPLING
 363 }
 364
 365 #if defined(__cplusplus) || defined(c_plusplus)
 366 }    // extern "C"
 367 #endif