mirror of
https://github.com/webmproject/libwebp.git
synced 2025-04-12 03:46:46 +02:00
e14ad93c0a
255*255*257>>16 == 254 while we want 255. BUG=webp:360 Change-Id: I2b9ac18f8802145f5a3d500c149ad9eceacbd75b
274 lines
8.5 KiB
C
274 lines
8.5 KiB
C
// Copyright 2014 Google Inc. All Rights Reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style license
|
|
// that can be found in the COPYING file in the root of the source
|
|
// tree. An additional intellectual property rights grant can be found
|
|
// in the file PATENTS. All contributing project authors may
|
|
// be found in the AUTHORS file in the root of the source tree.
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// WebPPicture tools: alpha handling, etc.
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <assert.h>
|
|
|
|
#include "./vp8i_enc.h"
|
|
#include "../dsp/yuv.h"
|
|
|
|
static WEBP_INLINE uint32_t MakeARGB32(int r, int g, int b) {
|
|
return (0xff000000u | (r << 16) | (g << 8) | b);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helper: clean up fully transparent area to help compressibility.
|
|
|
|
#define SIZE 8
|
|
#define SIZE2 (SIZE / 2)
|
|
static int IsTransparentARGBArea(const uint32_t* ptr, int stride, int size) {
|
|
int y, x;
|
|
for (y = 0; y < size; ++y) {
|
|
for (x = 0; x < size; ++x) {
|
|
if (ptr[x] & 0xff000000u) {
|
|
return 0;
|
|
}
|
|
}
|
|
ptr += stride;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void Flatten(uint8_t* ptr, int v, int stride, int size) {
|
|
int y;
|
|
for (y = 0; y < size; ++y) {
|
|
memset(ptr, v, size);
|
|
ptr += stride;
|
|
}
|
|
}
|
|
|
|
static void FlattenARGB(uint32_t* ptr, uint32_t v, int stride, int size) {
|
|
int x, y;
|
|
for (y = 0; y < size; ++y) {
|
|
for (x = 0; x < size; ++x) ptr[x] = v;
|
|
ptr += stride;
|
|
}
|
|
}
|
|
|
|
// Smoothen the luma components of transparent pixels. Return true if the whole
|
|
// block is transparent.
|
|
static int SmoothenBlock(const uint8_t* a_ptr, int a_stride, uint8_t* y_ptr,
|
|
int y_stride, int width, int height) {
|
|
int sum = 0, count = 0;
|
|
int x, y;
|
|
const uint8_t* alpha_ptr = a_ptr;
|
|
uint8_t* luma_ptr = y_ptr;
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
if (alpha_ptr[x] != 0) {
|
|
++count;
|
|
sum += luma_ptr[x];
|
|
}
|
|
}
|
|
alpha_ptr += a_stride;
|
|
luma_ptr += y_stride;
|
|
}
|
|
if (count > 0 && count < width * height) {
|
|
const uint8_t avg_u8 = (uint8_t)(sum / count);
|
|
alpha_ptr = a_ptr;
|
|
luma_ptr = y_ptr;
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
if (alpha_ptr[x] == 0) luma_ptr[x] = avg_u8;
|
|
}
|
|
alpha_ptr += a_stride;
|
|
luma_ptr += y_stride;
|
|
}
|
|
}
|
|
return (count == 0);
|
|
}
|
|
|
|
void WebPCleanupTransparentArea(WebPPicture* pic) {
|
|
int x, y, w, h;
|
|
if (pic == NULL) return;
|
|
w = pic->width / SIZE;
|
|
h = pic->height / SIZE;
|
|
|
|
// note: we ignore the left-overs on right/bottom, except for SmoothenBlock().
|
|
if (pic->use_argb) {
|
|
uint32_t argb_value = 0;
|
|
for (y = 0; y < h; ++y) {
|
|
int need_reset = 1;
|
|
for (x = 0; x < w; ++x) {
|
|
const int off = (y * pic->argb_stride + x) * SIZE;
|
|
if (IsTransparentARGBArea(pic->argb + off, pic->argb_stride, SIZE)) {
|
|
if (need_reset) {
|
|
argb_value = pic->argb[off];
|
|
need_reset = 0;
|
|
}
|
|
FlattenARGB(pic->argb + off, argb_value, pic->argb_stride, SIZE);
|
|
} else {
|
|
need_reset = 1;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const int width = pic->width;
|
|
const int height = pic->height;
|
|
const int y_stride = pic->y_stride;
|
|
const int uv_stride = pic->uv_stride;
|
|
const int a_stride = pic->a_stride;
|
|
uint8_t* y_ptr = pic->y;
|
|
uint8_t* u_ptr = pic->u;
|
|
uint8_t* v_ptr = pic->v;
|
|
const uint8_t* a_ptr = pic->a;
|
|
int values[3] = { 0 };
|
|
if (a_ptr == NULL || y_ptr == NULL || u_ptr == NULL || v_ptr == NULL) {
|
|
return;
|
|
}
|
|
for (y = 0; y + SIZE <= height; y += SIZE) {
|
|
int need_reset = 1;
|
|
for (x = 0; x + SIZE <= width; x += SIZE) {
|
|
if (SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,
|
|
SIZE, SIZE)) {
|
|
if (need_reset) {
|
|
values[0] = y_ptr[x];
|
|
values[1] = u_ptr[x >> 1];
|
|
values[2] = v_ptr[x >> 1];
|
|
need_reset = 0;
|
|
}
|
|
Flatten(y_ptr + x, values[0], y_stride, SIZE);
|
|
Flatten(u_ptr + (x >> 1), values[1], uv_stride, SIZE2);
|
|
Flatten(v_ptr + (x >> 1), values[2], uv_stride, SIZE2);
|
|
} else {
|
|
need_reset = 1;
|
|
}
|
|
}
|
|
if (x < width) {
|
|
SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,
|
|
width - x, SIZE);
|
|
}
|
|
a_ptr += SIZE * a_stride;
|
|
y_ptr += SIZE * y_stride;
|
|
u_ptr += SIZE2 * uv_stride;
|
|
v_ptr += SIZE2 * uv_stride;
|
|
}
|
|
if (y < height) {
|
|
const int sub_height = height - y;
|
|
for (x = 0; x + SIZE <= width; x += SIZE) {
|
|
SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,
|
|
SIZE, sub_height);
|
|
}
|
|
if (x < width) {
|
|
SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,
|
|
width - x, sub_height);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef SIZE
|
|
#undef SIZE2
|
|
|
|
void WebPCleanupTransparentAreaLossless(WebPPicture* const pic) {
|
|
int x, y, w, h;
|
|
uint32_t* argb;
|
|
assert(pic != NULL && pic->use_argb);
|
|
w = pic->width;
|
|
h = pic->height;
|
|
argb = pic->argb;
|
|
|
|
for (y = 0; y < h; ++y) {
|
|
for (x = 0; x < w; ++x) {
|
|
if ((argb[x] & 0xff000000) == 0) {
|
|
argb[x] = 0x00000000;
|
|
}
|
|
}
|
|
argb += pic->argb_stride;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Blend color and remove transparency info
|
|
|
|
#define BLEND(V0, V1, ALPHA) \
|
|
((((V0) * (255 - (ALPHA)) + (V1) * (ALPHA)) * 0x101 + 256) >> 16)
|
|
#define BLEND_10BIT(V0, V1, ALPHA) \
|
|
((((V0) * (1020 - (ALPHA)) + (V1) * (ALPHA)) * 0x101 + 1024) >> 18)
|
|
|
|
void WebPBlendAlpha(WebPPicture* pic, uint32_t background_rgb) {
|
|
const int red = (background_rgb >> 16) & 0xff;
|
|
const int green = (background_rgb >> 8) & 0xff;
|
|
const int blue = (background_rgb >> 0) & 0xff;
|
|
int x, y;
|
|
if (pic == NULL) return;
|
|
if (!pic->use_argb) {
|
|
const int uv_width = (pic->width >> 1); // omit last pixel during u/v loop
|
|
const int Y0 = VP8RGBToY(red, green, blue, YUV_HALF);
|
|
// VP8RGBToU/V expects the u/v values summed over four pixels
|
|
const int U0 = VP8RGBToU(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);
|
|
const int V0 = VP8RGBToV(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);
|
|
const int has_alpha = pic->colorspace & WEBP_CSP_ALPHA_BIT;
|
|
if (!has_alpha || pic->a == NULL) return; // nothing to do
|
|
for (y = 0; y < pic->height; ++y) {
|
|
// Luma blending
|
|
uint8_t* const y_ptr = pic->y + y * pic->y_stride;
|
|
uint8_t* const a_ptr = pic->a + y * pic->a_stride;
|
|
for (x = 0; x < pic->width; ++x) {
|
|
const int alpha = a_ptr[x];
|
|
if (alpha < 0xff) {
|
|
y_ptr[x] = BLEND(Y0, y_ptr[x], a_ptr[x]);
|
|
}
|
|
}
|
|
// Chroma blending every even line
|
|
if ((y & 1) == 0) {
|
|
uint8_t* const u = pic->u + (y >> 1) * pic->uv_stride;
|
|
uint8_t* const v = pic->v + (y >> 1) * pic->uv_stride;
|
|
uint8_t* const a_ptr2 =
|
|
(y + 1 == pic->height) ? a_ptr : a_ptr + pic->a_stride;
|
|
for (x = 0; x < uv_width; ++x) {
|
|
// Average four alpha values into a single blending weight.
|
|
// TODO(skal): might lead to visible contouring. Can we do better?
|
|
const int alpha =
|
|
a_ptr[2 * x + 0] + a_ptr[2 * x + 1] +
|
|
a_ptr2[2 * x + 0] + a_ptr2[2 * x + 1];
|
|
u[x] = BLEND_10BIT(U0, u[x], alpha);
|
|
v[x] = BLEND_10BIT(V0, v[x], alpha);
|
|
}
|
|
if (pic->width & 1) { // rightmost pixel
|
|
const int alpha = 2 * (a_ptr[2 * x + 0] + a_ptr2[2 * x + 0]);
|
|
u[x] = BLEND_10BIT(U0, u[x], alpha);
|
|
v[x] = BLEND_10BIT(V0, v[x], alpha);
|
|
}
|
|
}
|
|
memset(a_ptr, 0xff, pic->width);
|
|
}
|
|
} else {
|
|
uint32_t* argb = pic->argb;
|
|
const uint32_t background = MakeARGB32(red, green, blue);
|
|
for (y = 0; y < pic->height; ++y) {
|
|
for (x = 0; x < pic->width; ++x) {
|
|
const int alpha = (argb[x] >> 24) & 0xff;
|
|
if (alpha != 0xff) {
|
|
if (alpha > 0) {
|
|
int r = (argb[x] >> 16) & 0xff;
|
|
int g = (argb[x] >> 8) & 0xff;
|
|
int b = (argb[x] >> 0) & 0xff;
|
|
r = BLEND(red, r, alpha);
|
|
g = BLEND(green, g, alpha);
|
|
b = BLEND(blue, b, alpha);
|
|
argb[x] = MakeARGB32(r, g, b);
|
|
} else {
|
|
argb[x] = background;
|
|
}
|
|
}
|
|
}
|
|
argb += pic->argb_stride;
|
|
}
|
|
}
|
|
}
|
|
|
|
#undef BLEND
|
|
#undef BLEND_10BIT
|
|
|
|
//------------------------------------------------------------------------------
|