1114 lines
36 KiB
C
1114 lines
36 KiB
C
// Copyright 2011 Google Inc. All Rights Reserved.
|
|
//
|
|
// This code is licensed under the same terms as WebM:
|
|
// Software License Agreement: http://www.webmproject.org/license/software/
|
|
// Additional IP Rights Grant: http://www.webmproject.org/license/additional/
|
|
// -----------------------------------------------------------------------------
|
|
//
|
|
// WebPPicture utils: colorspace conversion, crop, ...
|
|
//
|
|
// Author: Skal (pascal.massimino@gmail.com)
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
|
|
#include "./vp8enci.h"
|
|
#include "../utils/rescaler.h"
|
|
#include "../utils/utils.h"
|
|
#include "../dsp/dsp.h"
|
|
#include "../dsp/yuv.h"
|
|
|
|
#if defined(__cplusplus) || defined(c_plusplus)
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define HALVE(x) (((x) + 1) >> 1)
|
|
#define IS_YUV_CSP(csp, YUV_CSP) (((csp) & WEBP_CSP_UV_MASK) == (YUV_CSP))
|
|
|
|
static const union {
|
|
uint32_t argb;
|
|
uint8_t bytes[4];
|
|
} test_endian = { 0xff000000u };
|
|
#define ALPHA_IS_LAST (test_endian.bytes[3] == 0xff)
|
|
|
|
//------------------------------------------------------------------------------
|
|
// WebPPicture
|
|
//------------------------------------------------------------------------------
|
|
|
|
int WebPPictureAlloc(WebPPicture* picture) {
|
|
if (picture != NULL) {
|
|
const WebPEncCSP uv_csp = picture->colorspace & WEBP_CSP_UV_MASK;
|
|
const int has_alpha = picture->colorspace & WEBP_CSP_ALPHA_BIT;
|
|
const int width = picture->width;
|
|
const int height = picture->height;
|
|
|
|
if (!picture->use_argb) {
|
|
const int y_stride = width;
|
|
const int uv_width = HALVE(width);
|
|
const int uv_height = HALVE(height);
|
|
const int uv_stride = uv_width;
|
|
int uv0_stride = 0;
|
|
int a_width, a_stride;
|
|
uint64_t y_size, uv_size, uv0_size, a_size, total_size;
|
|
uint8_t* mem;
|
|
|
|
// U/V
|
|
switch (uv_csp) {
|
|
case WEBP_YUV420:
|
|
break;
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
case WEBP_YUV400: // for now, we'll just reset the U/V samples
|
|
break;
|
|
case WEBP_YUV422:
|
|
uv0_stride = uv_width;
|
|
break;
|
|
case WEBP_YUV444:
|
|
uv0_stride = width;
|
|
break;
|
|
#endif
|
|
default:
|
|
return 0;
|
|
}
|
|
uv0_size = height * uv0_stride;
|
|
|
|
// alpha
|
|
a_width = has_alpha ? width : 0;
|
|
a_stride = a_width;
|
|
y_size = (uint64_t)y_stride * height;
|
|
uv_size = (uint64_t)uv_stride * uv_height;
|
|
a_size = (uint64_t)a_stride * height;
|
|
|
|
total_size = y_size + a_size + 2 * uv_size + 2 * uv0_size;
|
|
|
|
// Security and validation checks
|
|
if (width <= 0 || height <= 0 || // luma/alpha param error
|
|
uv_width < 0 || uv_height < 0) { // u/v param error
|
|
return 0;
|
|
}
|
|
// Clear previous buffer and allocate a new one.
|
|
WebPPictureFree(picture); // erase previous buffer
|
|
mem = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*mem));
|
|
if (mem == NULL) return 0;
|
|
|
|
// From now on, we're in the clear, we can no longer fail...
|
|
picture->memory_ = (void*)mem;
|
|
picture->y_stride = y_stride;
|
|
picture->uv_stride = uv_stride;
|
|
picture->a_stride = a_stride;
|
|
picture->uv0_stride = uv0_stride;
|
|
// TODO(skal): we could align the y/u/v planes and adjust stride.
|
|
picture->y = mem;
|
|
mem += y_size;
|
|
|
|
picture->u = mem;
|
|
mem += uv_size;
|
|
picture->v = mem;
|
|
mem += uv_size;
|
|
|
|
if (a_size) {
|
|
picture->a = mem;
|
|
mem += a_size;
|
|
}
|
|
if (uv0_size) {
|
|
picture->u0 = mem;
|
|
mem += uv0_size;
|
|
picture->v0 = mem;
|
|
mem += uv0_size;
|
|
}
|
|
} else {
|
|
void* memory;
|
|
const uint64_t argb_size = (uint64_t)width * height;
|
|
if (width <= 0 || height <= 0) {
|
|
return 0;
|
|
}
|
|
// Clear previous buffer and allocate a new one.
|
|
WebPPictureFree(picture); // erase previous buffer
|
|
memory = WebPSafeMalloc(argb_size, sizeof(*picture->argb));
|
|
if (memory == NULL) return 0;
|
|
|
|
// TODO(skal): align plane to cache line?
|
|
picture->memory_argb_ = memory;
|
|
picture->argb = (uint32_t*)memory;
|
|
picture->argb_stride = width;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// Remove reference to the ARGB buffer (doesn't free anything).
|
|
static void PictureResetARGB(WebPPicture* const picture) {
|
|
picture->memory_argb_ = NULL;
|
|
picture->argb = NULL;
|
|
picture->argb_stride = 0;
|
|
}
|
|
|
|
// Remove reference to the YUVA buffer (doesn't free anything).
|
|
static void PictureResetYUVA(WebPPicture* const picture) {
|
|
picture->memory_ = NULL;
|
|
picture->y = picture->u = picture->v = picture->a = NULL;
|
|
picture->u0 = picture->v0 = NULL;
|
|
picture->y_stride = picture->uv_stride = 0;
|
|
picture->a_stride = 0;
|
|
picture->uv0_stride = 0;
|
|
}
|
|
|
|
// Grab the 'specs' (writer, *opaque, width, height...) from 'src' and copy them
|
|
// into 'dst'. Mark 'dst' as not owning any memory.
|
|
static void WebPPictureGrabSpecs(const WebPPicture* const src,
|
|
WebPPicture* const dst) {
|
|
assert(src != NULL && dst != NULL);
|
|
*dst = *src;
|
|
PictureResetYUVA(dst);
|
|
PictureResetARGB(dst);
|
|
}
|
|
|
|
// Allocate a new argb buffer, discarding any existing one and preserving
|
|
// the other YUV(A) buffer.
|
|
static int PictureAllocARGB(WebPPicture* const picture) {
|
|
WebPPicture tmp;
|
|
free(picture->memory_argb_);
|
|
PictureResetARGB(picture);
|
|
picture->use_argb = 1;
|
|
WebPPictureGrabSpecs(picture, &tmp);
|
|
if (!WebPPictureAlloc(&tmp)) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
|
|
}
|
|
picture->memory_argb_ = tmp.memory_argb_;
|
|
picture->argb = tmp.argb;
|
|
picture->argb_stride = tmp.argb_stride;
|
|
return 1;
|
|
}
|
|
|
|
// Release memory owned by 'picture' (both YUV and ARGB buffers).
|
|
void WebPPictureFree(WebPPicture* picture) {
|
|
if (picture != NULL) {
|
|
free(picture->memory_);
|
|
free(picture->memory_argb_);
|
|
PictureResetYUVA(picture);
|
|
PictureResetARGB(picture);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Picture copying
|
|
|
|
// Not worth moving to dsp/enc.c (only used here).
|
|
static void CopyPlane(const uint8_t* src, int src_stride,
|
|
uint8_t* dst, int dst_stride, int width, int height) {
|
|
while (height-- > 0) {
|
|
memcpy(dst, src, width);
|
|
src += src_stride;
|
|
dst += dst_stride;
|
|
}
|
|
}
|
|
|
|
// Adjust top-left corner to chroma sample position.
|
|
static void SnapTopLeftPosition(const WebPPicture* const pic,
|
|
int* const left, int* const top) {
|
|
if (!pic->use_argb) {
|
|
const int is_yuv422 = IS_YUV_CSP(pic->colorspace, WEBP_YUV422);
|
|
if (IS_YUV_CSP(pic->colorspace, WEBP_YUV420) || is_yuv422) {
|
|
*left &= ~1;
|
|
if (!is_yuv422) *top &= ~1;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Adjust top-left corner and verify that the sub-rectangle is valid.
|
|
static int AdjustAndCheckRectangle(const WebPPicture* const pic,
|
|
int* const left, int* const top,
|
|
int width, int height) {
|
|
SnapTopLeftPosition(pic, left, top);
|
|
if ((*left) < 0 || (*top) < 0) return 0;
|
|
if (width <= 0 || height <= 0) return 0;
|
|
if ((*left) + width > pic->width) return 0;
|
|
if ((*top) + height > pic->height) return 0;
|
|
return 1;
|
|
}
|
|
|
|
int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) {
|
|
if (src == NULL || dst == NULL) return 0;
|
|
if (src == dst) return 1;
|
|
|
|
WebPPictureGrabSpecs(src, dst);
|
|
if (!WebPPictureAlloc(dst)) return 0;
|
|
|
|
if (!src->use_argb) {
|
|
CopyPlane(src->y, src->y_stride,
|
|
dst->y, dst->y_stride, dst->width, dst->height);
|
|
CopyPlane(src->u, src->uv_stride,
|
|
dst->u, dst->uv_stride, HALVE(dst->width), HALVE(dst->height));
|
|
CopyPlane(src->v, src->uv_stride,
|
|
dst->v, dst->uv_stride, HALVE(dst->width), HALVE(dst->height));
|
|
if (dst->a != NULL) {
|
|
CopyPlane(src->a, src->a_stride,
|
|
dst->a, dst->a_stride, dst->width, dst->height);
|
|
}
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
if (dst->u0 != NULL) {
|
|
int uv0_width = src->width;
|
|
if (IS_YUV_CSP(dst->colorspace, WEBP_YUV422)) {
|
|
uv0_width = HALVE(uv0_width);
|
|
}
|
|
CopyPlane(src->u0, src->uv0_stride,
|
|
dst->u0, dst->uv0_stride, uv0_width, dst->height);
|
|
CopyPlane(src->v0, src->uv0_stride,
|
|
dst->v0, dst->uv0_stride, uv0_width, dst->height);
|
|
}
|
|
#endif
|
|
} else {
|
|
CopyPlane((const uint8_t*)src->argb, 4 * src->argb_stride,
|
|
(uint8_t*)dst->argb, 4 * dst->argb_stride,
|
|
4 * dst->width, dst->height);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int WebPPictureIsView(const WebPPicture* picture) {
|
|
if (picture == NULL) return 0;
|
|
if (picture->use_argb) {
|
|
return (picture->memory_argb_ == NULL);
|
|
}
|
|
return (picture->memory_ == NULL);
|
|
}
|
|
|
|
int WebPPictureView(const WebPPicture* src,
|
|
int left, int top, int width, int height,
|
|
WebPPicture* dst) {
|
|
if (src == NULL || dst == NULL) return 0;
|
|
|
|
// verify rectangle position.
|
|
if (!AdjustAndCheckRectangle(src, &left, &top, width, height)) return 0;
|
|
|
|
if (src != dst) { // beware of aliasing! We don't want to leak 'memory_'.
|
|
WebPPictureGrabSpecs(src, dst);
|
|
}
|
|
dst->width = width;
|
|
dst->height = height;
|
|
if (!src->use_argb) {
|
|
dst->y = src->y + top * src->y_stride + left;
|
|
dst->u = src->u + (top >> 1) * src->uv_stride + (left >> 1);
|
|
dst->v = src->v + (top >> 1) * src->uv_stride + (left >> 1);
|
|
dst->y_stride = src->y_stride;
|
|
dst->uv_stride = src->uv_stride;
|
|
if (src->a != NULL) {
|
|
dst->a = src->a + top * src->a_stride + left;
|
|
dst->a_stride = src->a_stride;
|
|
}
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
if (src->u0 != NULL) {
|
|
const int left_pos =
|
|
IS_YUV_CSP(dst->colorspace, WEBP_YUV422) ? (left >> 1) : left;
|
|
dst->u0 = src->u0 + top * src->uv0_stride + left_pos;
|
|
dst->v0 = src->v0 + top * src->uv0_stride + left_pos;
|
|
dst->uv0_stride = src->uv0_stride;
|
|
}
|
|
#endif
|
|
} else {
|
|
dst->argb = src->argb + top * src->argb_stride + left;
|
|
dst->argb_stride = src->argb_stride;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Picture cropping
|
|
|
|
int WebPPictureCrop(WebPPicture* pic,
|
|
int left, int top, int width, int height) {
|
|
WebPPicture tmp;
|
|
|
|
if (pic == NULL) return 0;
|
|
if (!AdjustAndCheckRectangle(pic, &left, &top, width, height)) return 0;
|
|
|
|
WebPPictureGrabSpecs(pic, &tmp);
|
|
tmp.width = width;
|
|
tmp.height = height;
|
|
if (!WebPPictureAlloc(&tmp)) return 0;
|
|
|
|
if (!pic->use_argb) {
|
|
const int y_offset = top * pic->y_stride + left;
|
|
const int uv_offset = (top / 2) * pic->uv_stride + left / 2;
|
|
CopyPlane(pic->y + y_offset, pic->y_stride,
|
|
tmp.y, tmp.y_stride, width, height);
|
|
CopyPlane(pic->u + uv_offset, pic->uv_stride,
|
|
tmp.u, tmp.uv_stride, HALVE(width), HALVE(height));
|
|
CopyPlane(pic->v + uv_offset, pic->uv_stride,
|
|
tmp.v, tmp.uv_stride, HALVE(width), HALVE(height));
|
|
|
|
if (tmp.a != NULL) {
|
|
const int a_offset = top * pic->a_stride + left;
|
|
CopyPlane(pic->a + a_offset, pic->a_stride,
|
|
tmp.a, tmp.a_stride, width, height);
|
|
}
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
if (tmp.u0 != NULL) {
|
|
int w = width;
|
|
int left_pos = left;
|
|
if (IS_YUV_CSP(tmp.colorspace, WEBP_YUV422)) {
|
|
w = HALVE(w);
|
|
left_pos = HALVE(left_pos);
|
|
}
|
|
CopyPlane(pic->u0 + top * pic->uv0_stride + left_pos, pic->uv0_stride,
|
|
tmp.u0, tmp.uv0_stride, w, height);
|
|
CopyPlane(pic->v0 + top * pic->uv0_stride + left_pos, pic->uv0_stride,
|
|
tmp.v0, tmp.uv0_stride, w, height);
|
|
}
|
|
#endif
|
|
} else {
|
|
const uint8_t* const src =
|
|
(const uint8_t*)(pic->argb + top * pic->argb_stride + left);
|
|
CopyPlane(src, pic->argb_stride * 4,
|
|
(uint8_t*)tmp.argb, tmp.argb_stride * 4,
|
|
width * 4, height);
|
|
}
|
|
WebPPictureFree(pic);
|
|
*pic = tmp;
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Simple picture rescaler
|
|
|
|
static void RescalePlane(const uint8_t* src,
|
|
int src_width, int src_height, int src_stride,
|
|
uint8_t* dst,
|
|
int dst_width, int dst_height, int dst_stride,
|
|
int32_t* const work,
|
|
int num_channels) {
|
|
WebPRescaler rescaler;
|
|
int y = 0;
|
|
WebPRescalerInit(&rescaler, src_width, src_height,
|
|
dst, dst_width, dst_height, dst_stride,
|
|
num_channels,
|
|
src_width, dst_width,
|
|
src_height, dst_height,
|
|
work);
|
|
memset(work, 0, 2 * dst_width * num_channels * sizeof(*work));
|
|
while (y < src_height) {
|
|
y += WebPRescalerImport(&rescaler, src_height - y,
|
|
src + y * src_stride, src_stride);
|
|
WebPRescalerExport(&rescaler);
|
|
}
|
|
}
|
|
|
|
int WebPPictureRescale(WebPPicture* pic, int width, int height) {
|
|
WebPPicture tmp;
|
|
int prev_width, prev_height;
|
|
int32_t* work;
|
|
|
|
if (pic == NULL) return 0;
|
|
prev_width = pic->width;
|
|
prev_height = pic->height;
|
|
// if width is unspecified, scale original proportionally to height ratio.
|
|
if (width == 0) {
|
|
width = (prev_width * height + prev_height / 2) / prev_height;
|
|
}
|
|
// if height is unspecified, scale original proportionally to width ratio.
|
|
if (height == 0) {
|
|
height = (prev_height * width + prev_width / 2) / prev_width;
|
|
}
|
|
// Check if the overall dimensions still make sense.
|
|
if (width <= 0 || height <= 0) return 0;
|
|
|
|
WebPPictureGrabSpecs(pic, &tmp);
|
|
tmp.width = width;
|
|
tmp.height = height;
|
|
if (!WebPPictureAlloc(&tmp)) return 0;
|
|
|
|
if (!pic->use_argb) {
|
|
work = (int32_t*)WebPSafeMalloc(2ULL * width, sizeof(*work));
|
|
if (work == NULL) {
|
|
WebPPictureFree(&tmp);
|
|
return 0;
|
|
}
|
|
|
|
RescalePlane(pic->y, prev_width, prev_height, pic->y_stride,
|
|
tmp.y, width, height, tmp.y_stride, work, 1);
|
|
RescalePlane(pic->u,
|
|
HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
|
|
tmp.u,
|
|
HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
|
|
RescalePlane(pic->v,
|
|
HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
|
|
tmp.v,
|
|
HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
|
|
|
|
if (tmp.a != NULL) {
|
|
RescalePlane(pic->a, prev_width, prev_height, pic->a_stride,
|
|
tmp.a, width, height, tmp.a_stride, work, 1);
|
|
}
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
if (tmp.u0 != NULL) {
|
|
const int s = IS_YUV_CSP(tmp.colorspace, WEBP_YUV422) ? 2 : 1;
|
|
RescalePlane(
|
|
pic->u0, (prev_width + s / 2) / s, prev_height, pic->uv0_stride,
|
|
tmp.u0, (width + s / 2) / s, height, tmp.uv0_stride, work, 1);
|
|
RescalePlane(
|
|
pic->v0, (prev_width + s / 2) / s, prev_height, pic->uv0_stride,
|
|
tmp.v0, (width + s / 2) / s, height, tmp.uv0_stride, work, 1);
|
|
}
|
|
#endif
|
|
} else {
|
|
work = (int32_t*)WebPSafeMalloc(2ULL * width * 4, sizeof(*work));
|
|
if (work == NULL) {
|
|
WebPPictureFree(&tmp);
|
|
return 0;
|
|
}
|
|
|
|
RescalePlane((const uint8_t*)pic->argb, prev_width, prev_height,
|
|
pic->argb_stride * 4,
|
|
(uint8_t*)tmp.argb, width, height,
|
|
tmp.argb_stride * 4,
|
|
work, 4);
|
|
}
|
|
WebPPictureFree(pic);
|
|
free(work);
|
|
*pic = tmp;
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// WebPMemoryWriter: Write-to-memory
|
|
|
|
void WebPMemoryWriterInit(WebPMemoryWriter* writer) {
|
|
writer->mem = NULL;
|
|
writer->size = 0;
|
|
writer->max_size = 0;
|
|
}
|
|
|
|
int WebPMemoryWrite(const uint8_t* data, size_t data_size,
|
|
const WebPPicture* picture) {
|
|
WebPMemoryWriter* const w = (WebPMemoryWriter*)picture->custom_ptr;
|
|
uint64_t next_size;
|
|
if (w == NULL) {
|
|
return 1;
|
|
}
|
|
next_size = (uint64_t)w->size + data_size;
|
|
if (next_size > w->max_size) {
|
|
uint8_t* new_mem;
|
|
uint64_t next_max_size = 2ULL * w->max_size;
|
|
if (next_max_size < next_size) next_max_size = next_size;
|
|
if (next_max_size < 8192ULL) next_max_size = 8192ULL;
|
|
new_mem = (uint8_t*)WebPSafeMalloc(next_max_size, 1);
|
|
if (new_mem == NULL) {
|
|
return 0;
|
|
}
|
|
if (w->size > 0) {
|
|
memcpy(new_mem, w->mem, w->size);
|
|
}
|
|
free(w->mem);
|
|
w->mem = new_mem;
|
|
// down-cast is ok, thanks to WebPSafeMalloc
|
|
w->max_size = (size_t)next_max_size;
|
|
}
|
|
if (data_size > 0) {
|
|
memcpy(w->mem + w->size, data, data_size);
|
|
w->size += data_size;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Detection of non-trivial transparency
|
|
|
|
// Returns true if alpha[] has non-0xff values.
|
|
static int CheckNonOpaque(const uint8_t* alpha, int width, int height,
|
|
int x_step, int y_step) {
|
|
if (alpha == NULL) return 0;
|
|
while (height-- > 0) {
|
|
int x;
|
|
for (x = 0; x < width * x_step; x += x_step) {
|
|
if (alpha[x] != 0xff) return 1; // TODO(skal): check 4/8 bytes at a time.
|
|
}
|
|
alpha += y_step;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Checking for the presence of non-opaque alpha.
|
|
int WebPPictureHasTransparency(const WebPPicture* picture) {
|
|
if (picture == NULL) return 0;
|
|
if (!picture->use_argb) {
|
|
return CheckNonOpaque(picture->a, picture->width, picture->height,
|
|
1, picture->a_stride);
|
|
} else {
|
|
int x, y;
|
|
const uint32_t* argb = picture->argb;
|
|
if (argb == NULL) return 0;
|
|
for (y = 0; y < picture->height; ++y) {
|
|
for (x = 0; x < picture->width; ++x) {
|
|
if (argb[x] < 0xff000000u) return 1; // test any alpha values != 0xff
|
|
}
|
|
argb += picture->argb_stride;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// RGB -> YUV conversion
|
|
|
|
// TODO: we can do better than simply 2x2 averaging on U/V samples.
|
|
#define SUM4(ptr) ((ptr)[0] + (ptr)[step] + \
|
|
(ptr)[rgb_stride] + (ptr)[rgb_stride + step])
|
|
#define SUM2H(ptr) (2 * (ptr)[0] + 2 * (ptr)[step])
|
|
#define SUM2V(ptr) (2 * (ptr)[0] + 2 * (ptr)[rgb_stride])
|
|
#define SUM1(ptr) (4 * (ptr)[0])
|
|
#define RGB_TO_UV(x, y, SUM) { \
|
|
const int src = (2 * (step * (x) + (y) * rgb_stride)); \
|
|
const int dst = (x) + (y) * picture->uv_stride; \
|
|
const int r = SUM(r_ptr + src); \
|
|
const int g = SUM(g_ptr + src); \
|
|
const int b = SUM(b_ptr + src); \
|
|
picture->u[dst] = VP8RGBToU(r, g, b); \
|
|
picture->v[dst] = VP8RGBToV(r, g, b); \
|
|
}
|
|
|
|
#define RGB_TO_UV0(x_in, x_out, y, SUM) { \
|
|
const int src = (step * (x_in) + (y) * rgb_stride); \
|
|
const int dst = (x_out) + (y) * picture->uv0_stride; \
|
|
const int r = SUM(r_ptr + src); \
|
|
const int g = SUM(g_ptr + src); \
|
|
const int b = SUM(b_ptr + src); \
|
|
picture->u0[dst] = VP8RGBToU(r, g, b); \
|
|
picture->v0[dst] = VP8RGBToV(r, g, b); \
|
|
}
|
|
|
|
static void MakeGray(WebPPicture* const picture) {
|
|
int y;
|
|
const int uv_width = HALVE(picture->width);
|
|
const int uv_height = HALVE(picture->height);
|
|
for (y = 0; y < uv_height; ++y) {
|
|
memset(picture->u + y * picture->uv_stride, 128, uv_width);
|
|
memset(picture->v + y * picture->uv_stride, 128, uv_width);
|
|
}
|
|
}
|
|
|
|
static int ImportYUVAFromRGBA(const uint8_t* const r_ptr,
|
|
const uint8_t* const g_ptr,
|
|
const uint8_t* const b_ptr,
|
|
const uint8_t* const a_ptr,
|
|
int step, // bytes per pixel
|
|
int rgb_stride, // bytes per scanline
|
|
WebPPicture* const picture) {
|
|
const WebPEncCSP uv_csp = picture->colorspace & WEBP_CSP_UV_MASK;
|
|
int x, y;
|
|
const int width = picture->width;
|
|
const int height = picture->height;
|
|
const int has_alpha = CheckNonOpaque(a_ptr, width, height, step, rgb_stride);
|
|
|
|
picture->colorspace = uv_csp;
|
|
picture->use_argb = 0;
|
|
if (has_alpha) {
|
|
picture->colorspace |= WEBP_CSP_ALPHA_BIT;
|
|
}
|
|
if (!WebPPictureAlloc(picture)) return 0;
|
|
|
|
// Import luma plane
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
const int offset = step * x + y * rgb_stride;
|
|
picture->y[x + y * picture->y_stride] =
|
|
VP8RGBToY(r_ptr[offset], g_ptr[offset], b_ptr[offset]);
|
|
}
|
|
}
|
|
|
|
// Downsample U/V plane
|
|
if (uv_csp != WEBP_YUV400) {
|
|
for (y = 0; y < (height >> 1); ++y) {
|
|
for (x = 0; x < (width >> 1); ++x) {
|
|
RGB_TO_UV(x, y, SUM4);
|
|
}
|
|
if (width & 1) {
|
|
RGB_TO_UV(x, y, SUM2V);
|
|
}
|
|
}
|
|
if (height & 1) {
|
|
for (x = 0; x < (width >> 1); ++x) {
|
|
RGB_TO_UV(x, y, SUM2H);
|
|
}
|
|
if (width & 1) {
|
|
RGB_TO_UV(x, y, SUM1);
|
|
}
|
|
}
|
|
|
|
#ifdef WEBP_EXPERIMENTAL_FEATURES
|
|
// Store original U/V samples too
|
|
if (uv_csp == WEBP_YUV422) {
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < (width >> 1); ++x) {
|
|
RGB_TO_UV0(2 * x, x, y, SUM2H);
|
|
}
|
|
if (width & 1) {
|
|
RGB_TO_UV0(2 * x, x, y, SUM1);
|
|
}
|
|
}
|
|
} else if (uv_csp == WEBP_YUV444) {
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
RGB_TO_UV0(x, x, y, SUM1);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
} else {
|
|
MakeGray(picture);
|
|
}
|
|
|
|
if (has_alpha) {
|
|
assert(step >= 4);
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
picture->a[x + y * picture->a_stride] =
|
|
a_ptr[step * x + y * rgb_stride];
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int Import(WebPPicture* const picture,
|
|
const uint8_t* const rgb, int rgb_stride,
|
|
int step, int swap_rb, int import_alpha) {
|
|
const uint8_t* const r_ptr = rgb + (swap_rb ? 2 : 0);
|
|
const uint8_t* const g_ptr = rgb + 1;
|
|
const uint8_t* const b_ptr = rgb + (swap_rb ? 0 : 2);
|
|
const uint8_t* const a_ptr = import_alpha ? rgb + 3 : NULL;
|
|
const int width = picture->width;
|
|
const int height = picture->height;
|
|
|
|
if (!picture->use_argb) {
|
|
return ImportYUVAFromRGBA(r_ptr, g_ptr, b_ptr, a_ptr, step, rgb_stride,
|
|
picture);
|
|
}
|
|
if (import_alpha) {
|
|
picture->colorspace |= WEBP_CSP_ALPHA_BIT;
|
|
} else {
|
|
picture->colorspace &= ~WEBP_CSP_ALPHA_BIT;
|
|
}
|
|
if (!WebPPictureAlloc(picture)) return 0;
|
|
|
|
if (!import_alpha) {
|
|
int x, y;
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
const int offset = step * x + y * rgb_stride;
|
|
const uint32_t argb =
|
|
0xff000000u |
|
|
(r_ptr[offset] << 16) |
|
|
(g_ptr[offset] << 8) |
|
|
(b_ptr[offset]);
|
|
picture->argb[x + y * picture->argb_stride] = argb;
|
|
}
|
|
}
|
|
} else {
|
|
int x, y;
|
|
assert(step >= 4);
|
|
for (y = 0; y < height; ++y) {
|
|
for (x = 0; x < width; ++x) {
|
|
const int offset = step * x + y * rgb_stride;
|
|
const uint32_t argb = (a_ptr[offset] << 24) |
|
|
(r_ptr[offset] << 16) |
|
|
(g_ptr[offset] << 8) |
|
|
(b_ptr[offset]);
|
|
picture->argb[x + y * picture->argb_stride] = argb;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
#undef SUM4
|
|
#undef SUM2V
|
|
#undef SUM2H
|
|
#undef SUM1
|
|
#undef RGB_TO_UV
|
|
|
|
int WebPPictureImportRGB(WebPPicture* picture,
|
|
const uint8_t* rgb, int rgb_stride) {
|
|
return Import(picture, rgb, rgb_stride, 3, 0, 0);
|
|
}
|
|
|
|
int WebPPictureImportBGR(WebPPicture* picture,
|
|
const uint8_t* rgb, int rgb_stride) {
|
|
return Import(picture, rgb, rgb_stride, 3, 1, 0);
|
|
}
|
|
|
|
int WebPPictureImportRGBA(WebPPicture* picture,
|
|
const uint8_t* rgba, int rgba_stride) {
|
|
return Import(picture, rgba, rgba_stride, 4, 0, 1);
|
|
}
|
|
|
|
int WebPPictureImportBGRA(WebPPicture* picture,
|
|
const uint8_t* rgba, int rgba_stride) {
|
|
return Import(picture, rgba, rgba_stride, 4, 1, 1);
|
|
}
|
|
|
|
int WebPPictureImportRGBX(WebPPicture* picture,
|
|
const uint8_t* rgba, int rgba_stride) {
|
|
return Import(picture, rgba, rgba_stride, 4, 0, 0);
|
|
}
|
|
|
|
int WebPPictureImportBGRX(WebPPicture* picture,
|
|
const uint8_t* rgba, int rgba_stride) {
|
|
return Import(picture, rgba, rgba_stride, 4, 1, 0);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Automatic YUV <-> ARGB conversions.
|
|
|
|
int WebPPictureYUVAToARGB(WebPPicture* picture) {
|
|
if (picture == NULL) return 0;
|
|
if (picture->memory_ == NULL || picture->y == NULL ||
|
|
picture->u == NULL || picture->v == NULL) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
|
|
}
|
|
if ((picture->colorspace & WEBP_CSP_ALPHA_BIT) && picture->a == NULL) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
|
|
}
|
|
if ((picture->colorspace & WEBP_CSP_UV_MASK) != WEBP_YUV420) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
|
|
}
|
|
// Allocate a new argb buffer (discarding the previous one).
|
|
if (!PictureAllocARGB(picture)) return 0;
|
|
|
|
// Convert
|
|
{
|
|
int y;
|
|
const int width = picture->width;
|
|
const int height = picture->height;
|
|
const int argb_stride = 4 * picture->argb_stride;
|
|
uint8_t* dst = (uint8_t*)picture->argb;
|
|
const uint8_t *cur_u = picture->u, *cur_v = picture->v, *cur_y = picture->y;
|
|
WebPUpsampleLinePairFunc upsample = WebPGetLinePairConverter(ALPHA_IS_LAST);
|
|
|
|
// First row, with replicated top samples.
|
|
upsample(NULL, cur_y, cur_u, cur_v, cur_u, cur_v, NULL, dst, width);
|
|
cur_y += picture->y_stride;
|
|
dst += argb_stride;
|
|
// Center rows.
|
|
for (y = 1; y + 1 < height; y += 2) {
|
|
const uint8_t* const top_u = cur_u;
|
|
const uint8_t* const top_v = cur_v;
|
|
cur_u += picture->uv_stride;
|
|
cur_v += picture->uv_stride;
|
|
upsample(cur_y, cur_y + picture->y_stride, top_u, top_v, cur_u, cur_v,
|
|
dst, dst + argb_stride, width);
|
|
cur_y += 2 * picture->y_stride;
|
|
dst += 2 * argb_stride;
|
|
}
|
|
// Last row (if needed), with replicated bottom samples.
|
|
if (height > 1 && !(height & 1)) {
|
|
upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, width);
|
|
}
|
|
// Insert alpha values if needed, in replacement for the default 0xff ones.
|
|
if (picture->colorspace & WEBP_CSP_ALPHA_BIT) {
|
|
for (y = 0; y < height; ++y) {
|
|
uint32_t* const argb_dst = picture->argb + y * picture->argb_stride;
|
|
const uint8_t* const src = picture->a + y * picture->a_stride;
|
|
int x;
|
|
for (x = 0; x < width; ++x) {
|
|
argb_dst[x] = (argb_dst[x] & 0x00ffffffu) | (src[x] << 24);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int WebPPictureARGBToYUVA(WebPPicture* picture, WebPEncCSP colorspace) {
|
|
if (picture == NULL) return 0;
|
|
if (picture->argb == NULL) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_NULL_PARAMETER);
|
|
} else {
|
|
const uint8_t* const argb = (const uint8_t*)picture->argb;
|
|
const uint8_t* const r = ALPHA_IS_LAST ? argb + 2 : argb + 1;
|
|
const uint8_t* const g = ALPHA_IS_LAST ? argb + 1 : argb + 2;
|
|
const uint8_t* const b = ALPHA_IS_LAST ? argb + 0 : argb + 3;
|
|
const uint8_t* const a = ALPHA_IS_LAST ? argb + 3 : argb + 0;
|
|
// We work on a tmp copy of 'picture', because ImportYUVAFromRGBA()
|
|
// would be calling WebPPictureFree(picture) otherwise.
|
|
WebPPicture tmp = *picture;
|
|
PictureResetARGB(&tmp); // reset ARGB buffer so that it's not free()'d.
|
|
tmp.use_argb = 0;
|
|
tmp.colorspace = colorspace & WEBP_CSP_UV_MASK;
|
|
if (!ImportYUVAFromRGBA(r, g, b, a, 4, 4 * picture->argb_stride, &tmp)) {
|
|
return WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
|
|
}
|
|
// Copy back the YUV specs into 'picture'.
|
|
tmp.argb = picture->argb;
|
|
tmp.argb_stride = picture->argb_stride;
|
|
tmp.memory_argb_ = picture->memory_argb_;
|
|
*picture = tmp;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Helper: clean up fully transparent area to help compressibility.
|
|
|
|
#define SIZE 8
|
|
#define SIZE2 (SIZE / 2)
|
|
static int is_transparent_area(const uint8_t* ptr, int stride, int size) {
|
|
int y, x;
|
|
for (y = 0; y < size; ++y) {
|
|
for (x = 0; x < size; ++x) {
|
|
if (ptr[x]) {
|
|
return 0;
|
|
}
|
|
}
|
|
ptr += stride;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static WEBP_INLINE 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;
|
|
}
|
|
}
|
|
|
|
void WebPCleanupTransparentArea(WebPPicture* pic) {
|
|
int x, y, w, h;
|
|
const uint8_t* a_ptr;
|
|
int values[3] = { 0 };
|
|
|
|
if (pic == NULL) return;
|
|
|
|
a_ptr = pic->a;
|
|
if (a_ptr == NULL) return; // nothing to do
|
|
|
|
w = pic->width / SIZE;
|
|
h = pic->height / SIZE;
|
|
for (y = 0; y < h; ++y) {
|
|
int need_reset = 1;
|
|
for (x = 0; x < w; ++x) {
|
|
const int off_a = (y * pic->a_stride + x) * SIZE;
|
|
const int off_y = (y * pic->y_stride + x) * SIZE;
|
|
const int off_uv = (y * pic->uv_stride + x) * SIZE2;
|
|
if (is_transparent_area(a_ptr + off_a, pic->a_stride, SIZE)) {
|
|
if (need_reset) {
|
|
values[0] = pic->y[off_y];
|
|
values[1] = pic->u[off_uv];
|
|
values[2] = pic->v[off_uv];
|
|
need_reset = 0;
|
|
}
|
|
flatten(pic->y + off_y, values[0], pic->y_stride, SIZE);
|
|
flatten(pic->u + off_uv, values[1], pic->uv_stride, SIZE2);
|
|
flatten(pic->v + off_uv, values[2], pic->uv_stride, SIZE2);
|
|
} else {
|
|
need_reset = 1;
|
|
}
|
|
}
|
|
// ignore the left-overs on right/bottom
|
|
}
|
|
}
|
|
|
|
#undef SIZE
|
|
#undef SIZE2
|
|
|
|
//------------------------------------------------------------------------------
|
|
// local-min distortion
|
|
//
|
|
// For every pixel in the *reference* picture, we search for the local best
|
|
// match in the compressed image. This is not a symmetrical measure.
|
|
|
|
// search radius. Shouldn't be too large.
|
|
#define RADIUS 2
|
|
|
|
static float AccumulateLSIM(const uint8_t* src, int src_stride,
|
|
const uint8_t* ref, int ref_stride,
|
|
int w, int h) {
|
|
int x, y;
|
|
double total_sse = 0.;
|
|
for (y = 0; y < h; ++y) {
|
|
const int y_0 = (y - RADIUS < 0) ? 0 : y - RADIUS;
|
|
const int y_1 = (y + RADIUS + 1 >= h) ? h : y + RADIUS + 1;
|
|
for (x = 0; x < w; ++x) {
|
|
const int x_0 = (x - RADIUS < 0) ? 0 : x - RADIUS;
|
|
const int x_1 = (x + RADIUS + 1 >= w) ? w : x + RADIUS + 1;
|
|
double best_sse = 255. * 255.;
|
|
const double value = (double)ref[y * ref_stride + x];
|
|
int i, j;
|
|
for (j = y_0; j < y_1; ++j) {
|
|
const uint8_t* s = src + j * src_stride;
|
|
for (i = x_0; i < x_1; ++i) {
|
|
const double sse = (double)(s[i] - value) * (s[i] - value);
|
|
if (sse < best_sse) best_sse = sse;
|
|
}
|
|
}
|
|
total_sse += best_sse;
|
|
}
|
|
}
|
|
return (float)total_sse;
|
|
}
|
|
#undef RADIUS
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Distortion
|
|
|
|
// Max value returned in case of exact similarity.
|
|
static const double kMinDistortion_dB = 99.;
|
|
static float GetPSNR(const double v) {
|
|
return (float)((v > 0.) ? -4.3429448 * log(v / (255 * 255.))
|
|
: kMinDistortion_dB);
|
|
}
|
|
|
|
int WebPPictureDistortion(const WebPPicture* src, const WebPPicture* ref,
|
|
int type, float result[5]) {
|
|
DistoStats stats[5];
|
|
int has_alpha;
|
|
int uv_w, uv_h;
|
|
|
|
if (src == NULL || ref == NULL ||
|
|
src->width != ref->width || src->height != ref->height ||
|
|
src->y == NULL || ref->y == NULL ||
|
|
src->u == NULL || ref->u == NULL ||
|
|
src->v == NULL || ref->v == NULL ||
|
|
result == NULL) {
|
|
return 0;
|
|
}
|
|
// TODO(skal): provide distortion for ARGB too.
|
|
if (src->use_argb == 1 || src->use_argb != ref->use_argb) {
|
|
return 0;
|
|
}
|
|
|
|
has_alpha = !!(src->colorspace & WEBP_CSP_ALPHA_BIT);
|
|
if (has_alpha != !!(ref->colorspace & WEBP_CSP_ALPHA_BIT) ||
|
|
(has_alpha && (src->a == NULL || ref->a == NULL))) {
|
|
return 0;
|
|
}
|
|
|
|
memset(stats, 0, sizeof(stats));
|
|
|
|
uv_w = HALVE(src->width);
|
|
uv_h = HALVE(src->height);
|
|
if (type >= 2) {
|
|
float sse[4];
|
|
sse[0] = AccumulateLSIM(src->y, src->y_stride,
|
|
ref->y, ref->y_stride, src->width, src->height);
|
|
sse[1] = AccumulateLSIM(src->u, src->uv_stride,
|
|
ref->u, ref->uv_stride, uv_w, uv_h);
|
|
sse[2] = AccumulateLSIM(src->v, src->uv_stride,
|
|
ref->v, ref->uv_stride, uv_w, uv_h);
|
|
sse[3] = has_alpha ? AccumulateLSIM(src->a, src->a_stride,
|
|
ref->a, ref->a_stride,
|
|
src->width, src->height)
|
|
: 0.f;
|
|
result[0] = GetPSNR(sse[0] / (src->width * src->height));
|
|
result[1] = GetPSNR(sse[1] / (uv_w * uv_h));
|
|
result[2] = GetPSNR(sse[2] / (uv_w * uv_h));
|
|
result[3] = GetPSNR(sse[3] / (src->width * src->height));
|
|
{
|
|
double total_sse = sse[0] + sse[1] + sse[2];
|
|
int total_pixels = src->width * src->height + 2 * uv_w * uv_h;
|
|
if (has_alpha) {
|
|
total_pixels += src->width * src->height;
|
|
total_sse += sse[3];
|
|
}
|
|
result[4] = GetPSNR(total_sse / total_pixels);
|
|
}
|
|
} else {
|
|
int c;
|
|
VP8SSIMAccumulatePlane(src->y, src->y_stride,
|
|
ref->y, ref->y_stride,
|
|
src->width, src->height, &stats[0]);
|
|
VP8SSIMAccumulatePlane(src->u, src->uv_stride,
|
|
ref->u, ref->uv_stride,
|
|
uv_w, uv_h, &stats[1]);
|
|
VP8SSIMAccumulatePlane(src->v, src->uv_stride,
|
|
ref->v, ref->uv_stride,
|
|
uv_w, uv_h, &stats[2]);
|
|
if (has_alpha) {
|
|
VP8SSIMAccumulatePlane(src->a, src->a_stride,
|
|
ref->a, ref->a_stride,
|
|
src->width, src->height, &stats[3]);
|
|
}
|
|
for (c = 0; c <= 4; ++c) {
|
|
if (type == 1) {
|
|
const double v = VP8SSIMGet(&stats[c]);
|
|
result[c] = (float)((v < 1.) ? -10.0 * log10(1. - v)
|
|
: kMinDistortion_dB);
|
|
} else {
|
|
const double v = VP8SSIMGetSquaredError(&stats[c]);
|
|
result[c] = GetPSNR(v);
|
|
}
|
|
// Accumulate forward
|
|
if (c < 4) VP8SSIMAddStats(&stats[c], &stats[4]);
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Simplest high-level calls:
|
|
|
|
typedef int (*Importer)(WebPPicture* const, const uint8_t* const, int);
|
|
|
|
static size_t Encode(const uint8_t* rgba, int width, int height, int stride,
|
|
Importer import, float quality_factor, int lossless,
|
|
uint8_t** output) {
|
|
WebPPicture pic;
|
|
WebPConfig config;
|
|
WebPMemoryWriter wrt;
|
|
int ok;
|
|
|
|
if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, quality_factor) ||
|
|
!WebPPictureInit(&pic)) {
|
|
return 0; // shouldn't happen, except if system installation is broken
|
|
}
|
|
|
|
config.lossless = !!lossless;
|
|
pic.use_argb = !!lossless;
|
|
pic.width = width;
|
|
pic.height = height;
|
|
pic.writer = WebPMemoryWrite;
|
|
pic.custom_ptr = &wrt;
|
|
WebPMemoryWriterInit(&wrt);
|
|
|
|
ok = import(&pic, rgba, stride) && WebPEncode(&config, &pic);
|
|
WebPPictureFree(&pic);
|
|
if (!ok) {
|
|
free(wrt.mem);
|
|
*output = NULL;
|
|
return 0;
|
|
}
|
|
*output = wrt.mem;
|
|
return wrt.size;
|
|
}
|
|
|
|
#define ENCODE_FUNC(NAME, IMPORTER) \
|
|
size_t NAME(const uint8_t* in, int w, int h, int bps, float q, \
|
|
uint8_t** out) { \
|
|
return Encode(in, w, h, bps, IMPORTER, q, 0, out); \
|
|
}
|
|
|
|
ENCODE_FUNC(WebPEncodeRGB, WebPPictureImportRGB);
|
|
ENCODE_FUNC(WebPEncodeBGR, WebPPictureImportBGR);
|
|
ENCODE_FUNC(WebPEncodeRGBA, WebPPictureImportRGBA);
|
|
ENCODE_FUNC(WebPEncodeBGRA, WebPPictureImportBGRA);
|
|
|
|
#undef ENCODE_FUNC
|
|
|
|
#define LOSSLESS_DEFAULT_QUALITY 70.
|
|
#define LOSSLESS_ENCODE_FUNC(NAME, IMPORTER) \
|
|
size_t NAME(const uint8_t* in, int w, int h, int bps, uint8_t** out) { \
|
|
return Encode(in, w, h, bps, IMPORTER, LOSSLESS_DEFAULT_QUALITY, 1, out); \
|
|
}
|
|
|
|
LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessRGB, WebPPictureImportRGB);
|
|
LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessBGR, WebPPictureImportBGR);
|
|
LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessRGBA, WebPPictureImportRGBA);
|
|
LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessBGRA, WebPPictureImportBGRA);
|
|
|
|
#undef LOSSLESS_ENCODE_FUNC
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
#if defined(__cplusplus) || defined(c_plusplus)
|
|
} // extern "C"
|
|
#endif
|