mirror of
https://github.com/webmproject/libwebp.git
synced 2025-04-18 14:56:47 +02:00
7d67a1646d
If "exact" is false, we can modify the luma samples in fully transparent areas to facilitate lossy compression. Experiments on some PNG images show compression improvement of more than 20%. Change-Id: I1a728cfa920a6652bc1f600d87c01f7f648c4942
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) >> 16)
|
|
#define BLEND_10BIT(V0, V1, ALPHA) \
|
|
((((V0) * (1020 - (ALPHA)) + (V1) * (ALPHA)) * 0x101) >> 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
|
|
|
|
//------------------------------------------------------------------------------
|