Vikas Arora | af51b94 | 2014-08-28 10:51:12 -0700 | [diff] [blame] | 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 tools: alpha handling, etc. |
| 11 | // |
| 12 | // Author: Skal (pascal.massimino@gmail.com) |
| 13 | |
| 14 | #include "./vp8enci.h" |
| 15 | #include "../dsp/yuv.h" |
| 16 | |
| 17 | static WEBP_INLINE uint32_t MakeARGB32(int r, int g, int b) { |
| 18 | return (0xff000000u | (r << 16) | (g << 8) | b); |
| 19 | } |
| 20 | |
| 21 | //------------------------------------------------------------------------------ |
| 22 | // Helper: clean up fully transparent area to help compressibility. |
| 23 | |
| 24 | #define SIZE 8 |
| 25 | #define SIZE2 (SIZE / 2) |
| 26 | static int is_transparent_area(const uint8_t* ptr, int stride, int size) { |
| 27 | int y, x; |
| 28 | for (y = 0; y < size; ++y) { |
| 29 | for (x = 0; x < size; ++x) { |
| 30 | if (ptr[x]) { |
| 31 | return 0; |
| 32 | } |
| 33 | } |
| 34 | ptr += stride; |
| 35 | } |
| 36 | return 1; |
| 37 | } |
| 38 | |
| 39 | static int is_transparent_argb_area(const uint32_t* ptr, int stride, int size) { |
| 40 | int y, x; |
| 41 | for (y = 0; y < size; ++y) { |
| 42 | for (x = 0; x < size; ++x) { |
| 43 | if (ptr[x] & 0xff000000u) { |
| 44 | return 0; |
| 45 | } |
| 46 | } |
| 47 | ptr += stride; |
| 48 | } |
| 49 | return 1; |
| 50 | } |
| 51 | |
| 52 | static void flatten(uint8_t* ptr, int v, int stride, int size) { |
| 53 | int y; |
| 54 | for (y = 0; y < size; ++y) { |
| 55 | memset(ptr, v, size); |
| 56 | ptr += stride; |
| 57 | } |
| 58 | } |
| 59 | |
| 60 | static void flatten_argb(uint32_t* ptr, uint32_t v, int stride, int size) { |
| 61 | int x, y; |
| 62 | for (y = 0; y < size; ++y) { |
| 63 | for (x = 0; x < size; ++x) ptr[x] = v; |
| 64 | ptr += stride; |
| 65 | } |
| 66 | } |
| 67 | |
| 68 | void WebPCleanupTransparentArea(WebPPicture* pic) { |
| 69 | int x, y, w, h; |
| 70 | if (pic == NULL) return; |
| 71 | w = pic->width / SIZE; |
| 72 | h = pic->height / SIZE; |
| 73 | |
| 74 | // note: we ignore the left-overs on right/bottom |
| 75 | if (pic->use_argb) { |
| 76 | uint32_t argb_value = 0; |
| 77 | for (y = 0; y < h; ++y) { |
| 78 | int need_reset = 1; |
| 79 | for (x = 0; x < w; ++x) { |
| 80 | const int off = (y * pic->argb_stride + x) * SIZE; |
| 81 | if (is_transparent_argb_area(pic->argb + off, pic->argb_stride, SIZE)) { |
| 82 | if (need_reset) { |
| 83 | argb_value = pic->argb[off]; |
| 84 | need_reset = 0; |
| 85 | } |
| 86 | flatten_argb(pic->argb + off, argb_value, pic->argb_stride, SIZE); |
| 87 | } else { |
| 88 | need_reset = 1; |
| 89 | } |
| 90 | } |
| 91 | } |
| 92 | } else { |
| 93 | const uint8_t* const a_ptr = pic->a; |
| 94 | int values[3] = { 0 }; |
| 95 | if (a_ptr == NULL) return; // nothing to do |
| 96 | for (y = 0; y < h; ++y) { |
| 97 | int need_reset = 1; |
| 98 | for (x = 0; x < w; ++x) { |
| 99 | const int off_a = (y * pic->a_stride + x) * SIZE; |
| 100 | const int off_y = (y * pic->y_stride + x) * SIZE; |
| 101 | const int off_uv = (y * pic->uv_stride + x) * SIZE2; |
| 102 | if (is_transparent_area(a_ptr + off_a, pic->a_stride, SIZE)) { |
| 103 | if (need_reset) { |
| 104 | values[0] = pic->y[off_y]; |
| 105 | values[1] = pic->u[off_uv]; |
| 106 | values[2] = pic->v[off_uv]; |
| 107 | need_reset = 0; |
| 108 | } |
| 109 | flatten(pic->y + off_y, values[0], pic->y_stride, SIZE); |
| 110 | flatten(pic->u + off_uv, values[1], pic->uv_stride, SIZE2); |
| 111 | flatten(pic->v + off_uv, values[2], pic->uv_stride, SIZE2); |
| 112 | } else { |
| 113 | need_reset = 1; |
| 114 | } |
| 115 | } |
| 116 | } |
| 117 | } |
| 118 | } |
| 119 | |
| 120 | #undef SIZE |
| 121 | #undef SIZE2 |
| 122 | |
| 123 | //------------------------------------------------------------------------------ |
| 124 | // Blend color and remove transparency info |
| 125 | |
| 126 | #define BLEND(V0, V1, ALPHA) \ |
| 127 | ((((V0) * (255 - (ALPHA)) + (V1) * (ALPHA)) * 0x101) >> 16) |
| 128 | #define BLEND_10BIT(V0, V1, ALPHA) \ |
| 129 | ((((V0) * (1020 - (ALPHA)) + (V1) * (ALPHA)) * 0x101) >> 18) |
| 130 | |
| 131 | void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) { |
| 132 | const int red = (background_rgb >> 16) & 0xff; |
| 133 | const int green = (background_rgb >> 8) & 0xff; |
| 134 | const int blue = (background_rgb >> 0) & 0xff; |
| 135 | int x, y; |
| 136 | if (pic == NULL) return; |
| 137 | if (!pic->use_argb) { |
| 138 | const int uv_width = (pic->width >> 1); // omit last pixel during u/v loop |
| 139 | const int Y0 = VP8RGBToY(red, green, blue, YUV_HALF); |
| 140 | // VP8RGBToU/V expects the u/v values summed over four pixels |
| 141 | const int U0 = VP8RGBToU(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF); |
| 142 | const int V0 = VP8RGBToV(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF); |
| 143 | const int has_alpha = pic->colorspace & WEBP_CSP_ALPHA_BIT; |
| 144 | if (!has_alpha || pic->a == NULL) return; // nothing to do |
| 145 | for (y = 0; y < pic->height; ++y) { |
| 146 | // Luma blending |
| 147 | uint8_t* const y_ptr = pic->y + y * pic->y_stride; |
| 148 | uint8_t* const a_ptr = pic->a + y * pic->a_stride; |
| 149 | for (x = 0; x < pic->width; ++x) { |
| 150 | const int alpha = a_ptr[x]; |
| 151 | if (alpha < 0xff) { |
| 152 | y_ptr[x] = BLEND(Y0, y_ptr[x], a_ptr[x]); |
| 153 | } |
| 154 | } |
| 155 | // Chroma blending every even line |
| 156 | if ((y & 1) == 0) { |
| 157 | uint8_t* const u = pic->u + (y >> 1) * pic->uv_stride; |
| 158 | uint8_t* const v = pic->v + (y >> 1) * pic->uv_stride; |
| 159 | uint8_t* const a_ptr2 = |
| 160 | (y + 1 == pic->height) ? a_ptr : a_ptr + pic->a_stride; |
| 161 | for (x = 0; x < uv_width; ++x) { |
| 162 | // Average four alpha values into a single blending weight. |
| 163 | // TODO(skal): might lead to visible contouring. Can we do better? |
| 164 | const int alpha = |
| 165 | a_ptr[2 * x + 0] + a_ptr[2 * x + 1] + |
| 166 | a_ptr2[2 * x + 0] + a_ptr2[2 * x + 1]; |
| 167 | u[x] = BLEND_10BIT(U0, u[x], alpha); |
| 168 | v[x] = BLEND_10BIT(V0, v[x], alpha); |
| 169 | } |
| 170 | if (pic->width & 1) { // rightmost pixel |
| 171 | const int alpha = 2 * (a_ptr[2 * x + 0] + a_ptr2[2 * x + 0]); |
| 172 | u[x] = BLEND_10BIT(U0, u[x], alpha); |
| 173 | v[x] = BLEND_10BIT(V0, v[x], alpha); |
| 174 | } |
| 175 | } |
| 176 | memset(a_ptr, 0xff, pic->width); |
| 177 | } |
| 178 | } else { |
| 179 | uint32_t* argb = pic->argb; |
| 180 | const uint32_t background = MakeARGB32(red, green, blue); |
| 181 | for (y = 0; y < pic->height; ++y) { |
| 182 | for (x = 0; x < pic->width; ++x) { |
| 183 | const int alpha = (argb[x] >> 24) & 0xff; |
| 184 | if (alpha != 0xff) { |
| 185 | if (alpha > 0) { |
| 186 | int r = (argb[x] >> 16) & 0xff; |
| 187 | int g = (argb[x] >> 8) & 0xff; |
| 188 | int b = (argb[x] >> 0) & 0xff; |
| 189 | r = BLEND(red, r, alpha); |
| 190 | g = BLEND(green, g, alpha); |
| 191 | b = BLEND(blue, b, alpha); |
| 192 | argb[x] = MakeARGB32(r, g, b); |
| 193 | } else { |
| 194 | argb[x] = background; |
| 195 | } |
| 196 | } |
| 197 | } |
| 198 | argb += pic->argb_stride; |
| 199 | } |
| 200 | } |
| 201 | } |
| 202 | |
| 203 | #undef BLEND |
| 204 | #undef BLEND_10BIT |
| 205 | |
| 206 | //------------------------------------------------------------------------------ |