dany/libwebp
1
0
Fork 0
mirror of https://github.com/webmproject/libwebp.git synced 2025-01-24 21:52:55 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

prepare experimentation with yuv444 / 422

Browse Source 
+ add a simple rescaling function: WebPPictureRescale() for encoding
+ clean-up the memory managment around the alpha plane
+ fix some includes path by using "../webp/xxx.h" instead of "webp/xxx.h"

New flags for 'cwebp':
 -resize <width> <height>
 -444  (no effect)
 -422  (no effect)
 -400

Change-Id: I25a95f901493f939c2dd789e658493b83bd1abfa
This commit is contained in:
Pascal Massimino 2011-05-02 17:19:00 -07:00
parent 79cc49f5eb
commit 6d0e66c23e
25 changed files with 658 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Android.mk
View File

@ -2,15 +2,18 @@ LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
src/dec/alpha.c \
src/dec/bits.c \
src/dec/dsp.c \
src/dec/frame.c \
src/dec/idec.c \
src/dec/layer.c \
src/dec/quant.c \
src/dec/tree.c \
src/dec/vp8.c \
src/dec/webp.c \
src/dec/yuv.c \
src/enc/alpha.c \
src/enc/analysis.c \
src/enc/bit_writer.c \
src/enc/config.c \
@ -18,6 +21,7 @@ LOCAL_SRC_FILES := \
src/enc/filter.c \
src/enc/frame.c \
src/enc/iterator.c \
src/enc/layer.c \
src/enc/picture.c \
src/enc/quant.c \
src/enc/syntax.c \

4
Makefile.vc
View File

@ -121,6 +121,8 @@ X_OBJS= \
$(DIROBJ)\dec\webp.obj \
$(DIROBJ)\dec\yuv.obj \
$(DIROBJ)\dec\idec.obj \
$(DIROBJ)\dec\alpha.obj \
$(DIROBJ)\dec\layer.obj \
$(DIROBJ)\enc\analysis.obj \
$(DIROBJ)\enc\bit_writer.obj \
$(DIROBJ)\enc\config.obj \
@ -134,6 +136,8 @@ X_OBJS= \
$(DIROBJ)\enc\syntax.obj \
$(DIROBJ)\enc\tree.obj \
$(DIROBJ)\enc\webpenc.obj \
$(DIROBJ)\enc\alpha.obj \
$(DIROBJ)\enc\layer.obj \
$(RESOURCE)
EXAMPLES_OBJS = \

38
examples/cwebp.c
View File

@ -334,6 +334,11 @@ static int ReadPNG(FILE* in_file, WebPPicture* const pic, int keep_alpha) {
png_set_strip_alpha(png);
has_alpha = 0;
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (has_alpha) {
pic->colorspace |= WEBP_CSP_ALPHA_BIT;
}
#endif
num_passes = png_set_interlace_handling(png);
png_read_update_info(png, info);
@ -486,6 +491,10 @@ static void PrintExtraInfo(const WebPPicture* const pic, int short_output) {
fprintf(stderr, " transparency: %6d\n",
stats->alpha_data_size);
}
if (stats->layer_data_size) {
fprintf(stderr, " enhancement: %6d\n",
stats->layer_data_size);
}
fprintf(stderr, " Residuals bytes "
"|segment 1|segment 2|segment 3"
"|segment 4| total\n");
@ -605,8 +614,13 @@ static void HelpLong(void) {
printf(" -noalpha ............... discard any transparency information.\n");
printf(" -pass <int> ............ analysis pass number (1..10)\n");
printf(" -crop <x> <y> <w> <h> .. crop picture with the given rectangle\n");
printf(" -resize <w> <h> ........ resize picture (after any cropping)\n");
#ifdef WEBP_EXPERIMENTAL_FEATURES
printf(" -444 / -422 / -gray ..... Change colorspace\n");
#endif
printf(" -map <int> ............. print map of extra info.\n");
printf(" -d <file.pgm> .......... dump the compressed output (PGM file).\n");
printf("\n");
printf(" -short ................. condense printed message\n");
printf(" -quiet ................. don't print anything.\n");
@ -633,13 +647,16 @@ int main(int argc, const char *argv[]) {
int quiet = 0;
int keep_alpha = 0;
int crop = 0, crop_x = 0, crop_y = 0, crop_w = 0, crop_h = 0;
int resize_w = 0, resize_h = 0;
WebPPicture picture;
WebPConfig config;
WebPAuxStats stats;
Stopwatch stop_watch;
#ifdef WEBP_EXPERIMENTAL_FEATURES
keep_alpha = 1;
#endif
if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) {
fprintf(stderr, "Error! Version mismatch!\n");
goto Error;
@ -697,12 +714,23 @@ int main(int argc, const char *argv[]) {
keep_alpha = 0;
} else if (!strcmp(argv[c], "-map") && c < argc - 1) {
picture.extra_info_type = strtol(argv[++c], NULL, 0);
#ifdef WEBP_EXPERIMENTAL_FEATURES
} else if (!strcmp(argv[c], "-444")) {
picture.colorspace = WEBP_YUV444;
} else if (!strcmp(argv[c], "-422")) {
picture.colorspace = WEBP_YUV422;
} else if (!strcmp(argv[c], "-gray")) {
picture.colorspace = WEBP_YUV400;
#endif
} else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
crop = 1;
crop_x = strtol(argv[++c], NULL, 0);
crop_y = strtol(argv[++c], NULL, 0);
crop_w = strtol(argv[++c], NULL, 0);
crop_h = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-resize") && c < argc - 2) {
resize_w = strtol(argv[++c], NULL, 0);
resize_h = strtol(argv[++c], NULL, 0);
} else if (!strcmp(argv[c], "-noasm")) {
VP8GetCPUInfo = NULL;
} else if (!strcmp(argv[c], "-version")) {
@ -792,7 +820,15 @@ int main(int argc, const char *argv[]) {
fprintf(stderr, "Error! Cannot crop picture\n");
goto Error;
}
if (picture.extra_info_type > 0) AllocExtraInfo(&picture);
if ((resize_w | resize_h) > 0) {
if (!WebPPictureRescale(&picture, resize_w, resize_h)) {
fprintf(stderr, "Error! Cannot resize picture\n");
goto Error;
}
}
if (picture.extra_info_type > 0) {
AllocExtraInfo(&picture);
}
if (!WebPEncode(&config, &picture)) {
fprintf(stderr, "Error! Cannot encode picture as WebP\n");
goto Error;

6
makefile.unix
View File

@ -33,6 +33,9 @@ endif
# 'make -f makefile.unix EXTRA_FLAGS=-m32' to that effect.
# EXTRA_FLAGS += -m32
# Extra flags to enable experimental features and code
# EXTRA_FLAGS += -DUSE_EXPERIMENTAL_FEATURES
# Extra flags to emulate C89 strictness with the full ANSI
EXTRA_FLAGS += -Wextra -Wold-style-definition
EXTRA_FLAGS += -Wmissing-prototypes
@ -50,9 +53,10 @@ OBJS = src/enc/webpenc.o src/enc/bit_writer.o src/enc/syntax.o \
src/enc/tree.o src/enc/config.o src/enc/frame.o \
src/enc/quant.o src/enc/iterator.o src/enc/analysis.o \
src/enc/cost.o src/enc/picture.o src/enc/filter.o \
src/enc/layer.o \
src/dec/bits.o src/dec/dsp.o src/dec/frame.o src/dec/webp.o \
src/dec/quant.o src/dec/tree.o src/dec/vp8.o src/dec/yuv.o \
src/dec/idec.o src/dec/alpha.o
src/dec/idec.o src/dec/alpha.o src/dec/layer.o
HDRS = src/webp/encode.h src/enc/vp8enci.h src/enc/bit_writer.h \
src/enc/cost.h src/dec/bits.h src/dec/vp8i.h src/dec/yuv.h
OUTPUT = examples/cwebp examples/dwebp src/libwebp.a

3
src/dec/Makefile.am
View File

@ -1,7 +1,8 @@
AM_CPPFLAGS = -I$(top_srcdir)/src
libwebpdecode_la_SOURCES = bits.h vp8i.h yuv.h bits.c dsp.c frame.c \
quant.c tree.c vp8.c webp.c yuv.c idec.c alpha.c
quant.c tree.c vp8.c webp.c yuv.c idec.c alpha.c \
layer.c
libwebpdecode_la_LDFLAGS = -version-info 0:0:0
libwebpdecode_la_CPPFLAGS = $(USE_EXPERIMENTAL_CODE)
libwebpdecodeinclude_HEADERS = ../webp/decode.h ../webp/decode_vp8.h ../webp/types.h

2
src/dec/bits.h
View File

@ -13,7 +13,7 @@
#define WEBP_DEC_BITS_H_
#include <assert.h>
#include "webp/decode_vp8.h"
#include "../webp/decode_vp8.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

2
src/dec/frame.c
View File

@ -10,7 +10,7 @@
// Author: Skal (pascal.massimino@gmail.com)
#include <stdlib.h>
#include "vp8i.h"
#include "./vp8i.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

34
src/dec/layer.c Normal file
View File

@ -0,0 +1,34 @@
// Copyright 2011 Google Inc.
//
// 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/
// -----------------------------------------------------------------------------
//
// Enhancement layer (for YUV444/422)
//
// Author: Skal (pascal.massimino@gmail.com)
#include <assert.h>
#include <stdlib.h>
#include "vp8i.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
//-----------------------------------------------------------------------------
int VP8DecodeLayer(VP8Decoder* const dec) {
assert(dec);
assert(dec->layer_data_size_ > 0);
(void)dec;
// TODO: handle enhancement layer here.
return 1;
}
#if defined(__cplusplus) || defined(c_plusplus)
} // extern "C"
#endif

44
src/dec/vp8.c
View File

@ -375,26 +375,30 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
#ifdef WEBP_EXPERIMENTAL_FEATURES
// Extensions
if (dec->pic_hdr_.colorspace_) {
const uint32_t EXT_SIZE = 4;
uint32_t ext_size;
uint8_t ext_bits;
const uint8_t* ext_bytes_end = buf - EXT_SIZE;
if (frm_hdr->partition_length_ <= EXT_SIZE) {
const size_t kTrailerSize = 8;
const uint8_t kTrailerMarker = 0x01;
uint8_t* const ext_buf = buf - kTrailerSize;
size_t size;
if (frm_hdr->partition_length_ < kTrailerSize ||
ext_buf[kTrailerSize - 1] != kTrailerMarker) {
Error:
return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
"RIFF: Inconsistent extra information.");
}
ext_size = (ext_bytes_end[0] << 16) | (ext_bytes_end[1] << 8)
| (ext_bytes_end[2]);
ext_bits = ext_bytes_end[3];
ext_bytes_end -= ext_size;
if (!(ext_bits & 0x01) || (ext_size + EXT_SIZE > frm_hdr->partition_length_)) {
return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
"RIFF: Inconsistent extra information.");
}
if (!!(ext_bits & 0x02)) { // has alpha data
dec->alpha_data_size_ = ext_size;
dec->alpha_data_ = ext_bytes_end;
// Alpha
size = (ext_buf[4] << 0) | (ext_buf[5] << 8) | (ext_buf[6] << 16);
if (frm_hdr->partition_length_ < size + kTrailerSize) {
goto Error;
}
dec->alpha_data_ = (size > 0) ? ext_buf - size : NULL;
dec->alpha_data_size_ = size;
// Layer
size = (ext_buf[0] << 0) | (ext_buf[1] << 8) | (ext_buf[2] << 16);
dec->layer_data_size_ = size;
dec->layer_data_ = NULL; // will be set later
dec->layer_colorspace_ = ext_buf[3];
}
#endif
@ -651,6 +655,14 @@ static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
}
#endif
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (dec->layer_data_size_ > 0) {
if (!VP8DecodeLayer(dec)) {
return 0;
}
}
#endif
return 1;
}

9
src/dec/vp8i.h
View File

@ -244,13 +244,17 @@ struct VP8Decoder {
uint32_t non_zero_ac_;
// Filtering side-info
int filter_type_; // 0=off, 1=simple, 2=complex
int filter_type_; // 0=off, 1=simple, 2=complex
uint8_t filter_levels_[NUM_MB_SEGMENTS]; // precalculated per-segment
// extensions
const uint8_t* alpha_data_; // compressed alpha data (if present)
size_t alpha_data_size_;
uint8_t* alpha_plane_; // output
int layer_colorspace_;
const uint8_t* layer_data_; // compressed layer data (if present)
size_t layer_data_size_;
};
//-----------------------------------------------------------------------------
@ -283,6 +287,9 @@ int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br);
const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
int row, int num_rows);
// in layer.c
int VP8DecodeLayer(VP8Decoder* const dec);
// in dsp.c
typedef void (*VP8Idct)(const int16_t* coeffs, uint8_t* dst);
extern VP8Idct VP8Transform;

2
src/dec/webpi.h
View File

@ -16,7 +16,7 @@
extern "C" {
#endif
#include "webp/decode_vp8.h"
#include "../webp/decode_vp8.h"
// Decoding output parameters.
typedef struct {

2
src/dec/yuv.h
View File

@ -12,7 +12,7 @@
#ifndef WEBP_DEC_YUV_H_
#define WEBP_DEC_YUV_H_
#include "webp/decode_vp8.h"
#include "../webp/decode_vp8.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

2
src/enc/Makefile.am
View File

@ -3,7 +3,7 @@ AM_CPPFLAGS = -I$(top_srcdir)/src
libwebpencode_la_SOURCES = analysis.c bit_writer.c bit_writer.h \
config.c cost.c cost.h dsp.c dsp_sse2.c filter.c \
frame.c iterator.c picture.c quant.c \
syntax.c tree.c vp8enci.h webpenc.c alpha.c
syntax.c tree.c vp8enci.h webpenc.c alpha.c layer.c
libwebpencode_la_LDFLAGS = -version-info 0:0:0 -lm
libwebpencode_la_CPPFLAGS = $(USE_EXPERIMENTAL_CODE)
libwebpencodeinclude_HEADERS = ../webp/encode.h ../webp/types.h

18
src/enc/alpha.c
View File

@ -9,6 +9,7 @@
//
// Author: Skal (pascal.massimino@gmail.com)
#include <assert.h>
#include <stdlib.h>
#include "vp8enci.h"
@ -72,19 +73,29 @@ static int CompressAlpha(const uint8_t* data, size_t data_size,
#endif /* WEBP_EXPERIMENTAL_FEATURES */
int VP8EncProcessAlpha(VP8Encoder* enc) {
void VP8EncInitAlpha(VP8Encoder* enc) {
enc->has_alpha_ = (enc->pic_->a != NULL);
enc->alpha_data_ = NULL;
enc->alpha_data_size_ = 0;
}
void VP8EncCodeAlphaBlock(VP8EncIterator* it) {
(void)it;
// Nothing for now. We just ZLIB-compress in the end.
}
int VP8EncFinishAlpha(VP8Encoder* enc) {
if (enc->has_alpha_) {
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (enc->pic_->a) {
const WebPPicture* pic = enc->pic_;
assert(pic->a);
if (!CompressAlpha(pic->a, pic->width * pic->height,
&enc->alpha_data_, &enc->alpha_data_size_,
enc->config_->alpha_compression)) {
return 0;
}
#endif
}
#endif /* WEBP_EXPERIMENTAL_FEATURES */
return 1;
}
@ -92,6 +103,7 @@ void VP8EncDeleteAlpha(VP8Encoder* enc) {
free(enc->alpha_data_);
enc->alpha_data_ = NULL;
enc->alpha_data_size_ = 0;
enc->has_alpha_ = 0;
}
#if defined(__cplusplus) || defined(c_plusplus)

2
src/enc/config.c
View File

@ -10,7 +10,7 @@
// Author: Skal (pascal.massimino@gmail.com)
#include <assert.h>
#include "webp/encode.h"
#include "../webp/encode.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

8
src/enc/frame.c
View File

@ -568,6 +568,14 @@ int VP8EncLoop(VP8Encoder* const enc) {
} else { // reset predictors after a skip
ResetAfterSkip(&it);
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (enc->has_alpha_) {
VP8EncCodeAlphaBlock(&it);
}
if (enc->use_layer_) {
VP8EncCodeLayerBlock(&it);
}
#endif
StoreSideInfo(&it);
VP8StoreFilterStats(&it);
VP8IteratorExport(&it);

12
src/enc/iterator.c
View File

@ -148,11 +148,13 @@ void VP8IteratorExport(const VP8EncIterator* const it) {
memcpy(ydst + i * pic->y_stride, ysrc + i * BPS, w);
}
// U/V plane
w = (w + 1) / 2;
h = (h + 1) / 2;
for (i = 0; i < h; ++i) {
memcpy(udst + i * pic->uv_stride, usrc + i * BPS, w);
memcpy(vdst + i * pic->uv_stride, vsrc + i * BPS, w);
{
const int uv_w = (w + 1) / 2;
const int uv_h = (h + 1) / 2;
for (i = 0; i < uv_h; ++i) {
memcpy(udst + i * pic->uv_stride, usrc + i * BPS, uv_w);
memcpy(vdst + i * pic->uv_stride, vsrc + i * BPS, uv_w);
}
}
}
}

55
src/enc/layer.c Normal file
View File

@ -0,0 +1,55 @@
// Copyright 2011 Google Inc.
//
// 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/
// -----------------------------------------------------------------------------
//
// Enhancement layer (for YUV444/422)
//
// Author: Skal (pascal.massimino@gmail.com)
#include <assert.h>
#include <stdlib.h>
#include "vp8enci.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif
#ifdef WEBP_EXPERIMENTAL_FEATURES
#endif /* WEBP_EXPERIMENTAL_FEATURES */
//-----------------------------------------------------------------------------
void VP8EncInitLayer(VP8Encoder* const enc) {
enc->use_layer_ = (enc->pic_->u0 != NULL);
enc->layer_data_size_ = 0;
enc->layer_data_ = NULL;
if (enc->use_layer_) {
VP8BitWriterInit(&enc->layer_bw_, enc->mb_w_ * enc->mb_h_ * 3);
}
}
void VP8EncCodeLayerBlock(VP8EncIterator* it) {
(void)it; // remove a warning
#ifdef WEBP_EXPERIMENTAL_FEATURES
#endif /* WEBP_EXPERIMENTAL_FEATURES */
}
int VP8EncFinishLayer(VP8Encoder* const enc) {
if (enc->use_layer_) {
enc->layer_data_ = VP8BitWriterFinish(&enc->layer_bw_);
enc->layer_data_size_ = VP8BitWriterSize(&enc->layer_bw_);
}
return 1;
}
void VP8EncDeleteLayer(VP8Encoder* enc) {
free(enc->layer_data_);
}
#if defined(__cplusplus) || defined(c_plusplus)
} // extern "C"
#endif

424
src/enc/picture.c
View File

@ -23,77 +23,115 @@ extern "C" {
int WebPPictureAlloc(WebPPicture* const picture) {
if (picture) {
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;
const int uv_width = (width + 1) / 2;
const int uv_height = (height + 1) / 2;
const uint64_t y_size = (uint64_t)width * height;
const uint64_t uv_size = (uint64_t)uv_width * uv_height;
const uint64_t total_size = y_size + 2 * uv_size;
const int y_stride = width;
const int uv_width = (width + 1) / 2, uv_height = (height + 1) / 2;
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 (uv_width <= 0 || uv_height <= 0 || // check param error
if (width <= 0 || height <= 0 || // check for luma/alpha param error
uv_width < 0 || uv_height < 0 || // check for u/v param error
y_size >= (1ULL << 40) || // check for reasonable global size
(size_t)total_size != total_size) { // check for overflow on 32bit
return 0;
}
picture->y_stride = width;
picture->uv_stride = uv_width;
picture->y_stride = y_stride;
picture->uv_stride = uv_stride;
picture->a_stride = a_stride;
picture->uv0_stride = uv0_stride;
WebPPictureFree(picture); // erase previous buffer
picture->y = (uint8_t*)malloc((size_t)total_size);
if (picture->y == NULL) return 0;
picture->u = picture->y + y_size;
picture->v = picture->u + uv_size;
}
return 1;
}
mem = (uint8_t*)malloc((size_t)total_size);
if (mem == NULL) return 0;
int WebPPictureAddAlphaPlane(WebPPicture* const picture) {
if (picture) {
const int width = picture->width;
const int height = picture->height;
const int a_stride = width;
const uint64_t a_size = (uint64_t)a_stride * height;
// Security and validation checks
if (width <= 0 || height <= 0 || // check param error
a_size >= (1ULL << 40) || // check for reasonable global size
(size_t)a_size != a_size) { // check for overflow on 32bit
return 0;
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;
}
free(picture->a); // erase previous buffer
picture->a = (uint8_t*)malloc((size_t)a_size);
picture->a_stride = a_stride;
return (picture->a != NULL);
}
return 1;
}
// Grab the 'specs' (writer, *opaque, width, height...) from 'src' and copy them
// into 'dst'. Mark 'dst' as not owning any memory. 'src' can be NULL.
static void WebPPictureGrabSpecs(const WebPPicture* const src,
WebPPicture* const dst) {
if (src) *dst = *src;
dst->y = dst->u = dst->v = NULL;
dst->u0 = dst->v0 = NULL;
dst->a = NULL;
}
// Release memory owned by 'picture'.
void WebPPictureFree(WebPPicture* const picture) {
if (picture) {
free(picture->y);
picture->y = picture->u = picture->v = NULL;
free(picture->a);
picture->a = NULL;
WebPPictureGrabSpecs(NULL, picture);
}
}
//-----------------------------------------------------------------------------
// Picture copying
int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst) {
int y;
if (src == NULL || dst == NULL) return 0;
if (src == dst) return 1;
*dst = *src;
dst->y = NULL;
dst->a = NULL;
WebPPictureGrabSpecs(src, dst);
if (!WebPPictureAlloc(dst)) return 0;
if (src->a != NULL && !WebPPictureAddAlphaPlane(dst)) return 0;
for (y = 0; y < dst->height; ++y) {
memcpy(dst->y + y * dst->y_stride,
src->y + y * src->y_stride, src->width);
if (dst->a != NULL) {
memcpy(dst->a + y * dst->a_stride,
src->a + y * src->a_stride, src->width);
}
}
for (y = 0; y < (dst->height + 1) / 2; ++y) {
memcpy(dst->u + y * dst->uv_stride,
@ -101,9 +139,32 @@ int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst) {
memcpy(dst->v + y * dst->uv_stride,
src->v + y * src->uv_stride, (src->width + 1) / 2);
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (dst->a != NULL) {
for (y = 0; y < dst->height; ++y) {
memcpy(dst->a + y * dst->a_stride,
src->a + y * src->a_stride, src->width);
}
}
if (dst->u0 != NULL) {
int uv0_width = src->width;
if ((dst->colorspace & WEBP_CSP_UV_MASK) == WEBP_YUV422) {
uv0_width = (uv0_width + 1) / 2;
}
for (y = 0; y < dst->height; ++y) {
memcpy(dst->u0 + y * dst->uv0_stride,
src->u0 + y * src->uv0_stride, uv0_width);
memcpy(dst->v0 + y * dst->uv0_stride,
src->v0 + y * src->uv0_stride, uv0_width);
}
}
#endif
return 1;
}
//-----------------------------------------------------------------------------
// Picture cropping
int WebPPictureCrop(WebPPicture* const pic,
int left, int top, int width, int height) {
WebPPicture tmp;
@ -114,32 +175,202 @@ int WebPPictureCrop(WebPPicture* const pic,
if (left < 0 || ((left + width + 1) & ~1) > pic->width) return 0;
if (top < 0 || ((top + height + 1) & ~1) > pic->height) return 0;
tmp = *pic;
tmp.y = NULL;
tmp.a = NULL;
WebPPictureGrabSpecs(pic, &tmp);
tmp.width = width;
tmp.height = height;
if (!WebPPictureAlloc(&tmp)) return 0;
if (pic->a != NULL && !WebPPictureAddAlphaPlane(&tmp)) return 0;
for (y = 0; y < height; ++y) {
memcpy(tmp.y + y * tmp.y_stride,
pic->y + (top + y) * pic->y_stride + left, width);
if (tmp.a) {
memcpy(tmp.a + y * tmp.a_stride,
pic->a + (top + y) * pic->a_stride + left, width);
}
}
for (y = 0; y < (height + 1) / 2; ++y) {
const int offset = (y + top / 2) * pic->uv_stride + left / 2;
memcpy(tmp.u + y * tmp.uv_stride, pic->u + offset, (width + 1) / 2);
memcpy(tmp.v + y * tmp.uv_stride, pic->v + offset, (width + 1) / 2);
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (tmp.a) {
for (y = 0; y < height; ++y) {
memcpy(tmp.a + y * tmp.a_stride,
pic->a + (top + y) * pic->a_stride + left, width);
}
}
if (tmp.u0) {
int w = width;
int l = left;
if (tmp.colorspace == WEBP_YUV422) {
w = (w + 1) / 2;
l = (l + 1) / 2;
}
for (y = 0; y < height; ++y) {
memcpy(tmp.u0 + y * tmp.uv0_stride,
pic->u0 + (top + y) * pic->uv0_stride + l, w);
memcpy(tmp.v0 + y * tmp.uv0_stride,
pic->v0 + (top + y) * pic->uv0_stride + l, w);
}
}
#endif
WebPPictureFree(pic);
*pic = tmp;
return 1;
}
//-----------------------------------------------------------------------------
// Simple picture rescaler
#define RFIX 20
#define MULT(x,y) (((int64_t)(x) * (y) + (1 << (RFIX - 1))) >> RFIX)
static inline void ImportRow(const uint8_t* src, int src_width,
int32_t* frow, int32_t* irow, int dst_width) {
const int x_expand = (src_width < dst_width);
const int fx_scale = (1 << RFIX) / dst_width;
int x_in = 0;
int x_out;
int x_accum = 0;
if (!x_expand) {
int sum = 0;
for (x_out = 0; x_out < dst_width; ++x_out) {
x_accum += src_width - dst_width;
for (; x_accum > 0; x_accum -= dst_width) {
sum += src[x_in++];
}
{ // Emit next horizontal pixel.
const int32_t base = src[x_in++];
const int32_t frac = base * (-x_accum);
frow[x_out] = (sum + base) * dst_width - frac;
sum = MULT(frac, fx_scale); // fresh fractional start for next pixel
}
}
} else { // simple bilinear interpolation
int left = src[0], right = src[0];
for (x_out = 0; x_out < dst_width; ++x_out) {
if (x_accum < 0) {
left = right;
right = src[++x_in];
x_accum += dst_width - 1;
}
frow[x_out] = right * (dst_width - 1) + (left - right) * x_accum;
x_accum -= src_width - 1;
}
}
// Accumulate the new row's contribution
for (x_out = 0; x_out < dst_width; ++x_out) {
irow[x_out] += frow[x_out];
}
}
static void ExportRow(int32_t* frow, int32_t* irow, uint8_t* dst, int dst_width,
const int yscale, const int fxy_scale) {
int x_out;
for (x_out = 0; x_out < dst_width; ++x_out) {
const int frac = MULT(frow[x_out], yscale);
const int v = MULT(irow[x_out] - frac, fxy_scale);
dst[x_out] = (!(v & ~0xff)) ? v : (v < 0) ? 0 : 255;
irow[x_out] = frac; // new fractional start
}
}
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) {
const int x_expand = (src_width < dst_width);
const int fy_scale = (1 << RFIX) / dst_height;
const int fxy_scale = x_expand ?
((int64_t)dst_height << RFIX) / (dst_width * src_height) :
((int64_t)dst_height << RFIX) / (src_width * src_height);
int y_accum = src_height;
int y;
int32_t* irow = work; // integral contribution
int32_t* frow = work + dst_width; // fractional contribution
memset(work, 0, 2 * dst_width * sizeof(*work));
for (y = 0; y < src_height; ++y) {
// import new contribution of one source row.
ImportRow(src, src_width, frow, irow, dst_width);
src += src_stride;
// emit output row(s)
y_accum -= dst_height;
for (; y_accum <= 0; y_accum += src_height) {
const int yscale = fy_scale * (-y_accum);
ExportRow(frow, irow, dst, dst_width, yscale, fxy_scale);
dst += dst_stride;
}
}
}
#undef MULT
#undef RFIX
int WebPPictureRescale(WebPPicture* const 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;
work = malloc(2 * width * sizeof(int32_t));
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);
RescalePlane(pic->u,
(prev_width + 1) / 2, (prev_height + 1) / 2, pic->uv_stride,
tmp.u,
(width + 1) / 2, (height + 1) / 2, tmp.uv_stride, work);
RescalePlane(pic->v,
(prev_width + 1) / 2, (prev_height + 1) / 2, pic->uv_stride,
tmp.v,
(width + 1) / 2, (height + 1) / 2, tmp.uv_stride, work);
#ifdef WEBP_EXPERIMENTAL_FEATURES
if (tmp.a) {
RescalePlane(pic->a, prev_width, prev_height, pic->a_stride,
tmp.a, width, height, tmp.a_stride, work);
}
if (tmp.u0) {
int s = 1;
if ((tmp.colorspace & WEBP_CSP_UV_MASK) == WEBP_YUV422) {
s = 2;
}
RescalePlane(
pic->u0, (prev_width + s / 2) / s, prev_height, pic->uv0_stride,
tmp.u0, (width + s / 2) / s, height, tmp.uv0_stride, work);
RescalePlane(
pic->v0, (prev_width + s / 2) / s, prev_height, pic->uv0_stride,
tmp.v0, (width + s / 2) / s, height, tmp.uv0_stride, work);
}
#endif
WebPPictureFree(pic);
free(work);
*pic = tmp;
return 1;
}
//-----------------------------------------------------------------------------
// Write-to-memory
@ -232,49 +463,98 @@ static inline int rgb_to_v(int r, int g, int b) {
picture->v[dst] = rgb_to_v(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] = rgb_to_u(r, g, b); \
picture->v0[dst] = rgb_to_v(r, g, b); \
}
static void MakeGray(WebPPicture* const picture) {
int y;
const int uv_width = (picture->width + 1) >> 1;
for (y = 0; y < ((picture->height + 1) >> 1); ++y) {
memset(picture->u + y * picture->uv_stride, 128, uv_width);
memset(picture->v + y * picture->uv_stride, 128, uv_width);
}
}
static int Import(WebPPicture* const picture,
const uint8_t* const rgb, int rgb_stride,
int step, int swap_rb, int import_alpha) {
const WebPEncCSP uv_csp = picture->colorspace & WEBP_CSP_UV_MASK;
int x, y;
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 = rgb + 3;
const int width = picture->width;
const int height = picture->height;
for (y = 0; y < picture->height; ++y) {
for (x = 0; x < picture->width; ++x) {
// 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] =
rgb_to_y(r_ptr[offset], g_ptr[offset], b_ptr[offset]);
}
}
for (y = 0; y < (picture->height >> 1); ++y) {
for (x = 0; x < (picture->width >> 1); ++x) {
RGB_TO_UV(x, y, SUM4);
// 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 (picture->width & 1) {
RGB_TO_UV(x, y, SUM2V);
}
}
if (picture->width & 1) {
RGB_TO_UV(x, y, SUM2V);
}
}
if (picture->height & 1) {
for (x = 0; x < (picture->width >> 1); ++x) {
RGB_TO_UV(x, y, SUM2H);
}
if (picture->width & 1) {
RGB_TO_UV(x, y, SUM1);
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 (import_alpha) {
#ifdef WEBP_EXPERIMENTAL_FEATURES
const uint8_t* const a_ptr = rgb + 3;
assert(step >= 4);
if (!WebPPictureAddAlphaPlane(picture)) {
return 0;
}
for (y = 0; y < picture->height; ++y) {
for (x = 0; x < picture->width; ++x) {
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];
}
}
#endif
}
return 1;
}
@ -286,24 +566,28 @@ static int Import(WebPPicture* const picture,
int WebPPictureImportRGB(WebPPicture* const picture,
const uint8_t* const rgb, int rgb_stride) {
picture->colorspace &= ~WEBP_CSP_ALPHA_BIT;
if (!WebPPictureAlloc(picture)) return 0;
return Import(picture, rgb, rgb_stride, 3, 0, 0);
}
int WebPPictureImportBGR(WebPPicture* const picture,
const uint8_t* const rgb, int rgb_stride) {
picture->colorspace &= ~WEBP_CSP_ALPHA_BIT;
if (!WebPPictureAlloc(picture)) return 0;
return Import(picture, rgb, rgb_stride, 3, 1, 0);
}
int WebPPictureImportRGBA(WebPPicture* const picture,
const uint8_t* const rgba, int rgba_stride) {
picture->colorspace |= WEBP_CSP_ALPHA_BIT;
if (!WebPPictureAlloc(picture)) return 0;
return Import(picture, rgba, rgba_stride, 4, 0, 1);
}
int WebPPictureImportBGRA(WebPPicture* const picture,
const uint8_t* const rgba, int rgba_stride) {
picture->colorspace |= WEBP_CSP_ALPHA_BIT;
if (!WebPPictureAlloc(picture)) return 0;
return Import(picture, rgba, rgba_stride, 4, 1, 1);
}

43
src/enc/syntax.c
View File

@ -156,24 +156,40 @@ static int EmitPartitionsSize(const VP8Encoder* const enc,
//-----------------------------------------------------------------------------
#ifdef WEBP_EXPERIMENTAL_FEATURES
static void PutLE24(uint8_t* buf, size_t value) {
buf[0] = (value >> 0) & 0xff;
buf[1] = (value >> 8) & 0xff;
buf[2] = (value >> 16) & 0xff;
}
static int WriteExtensions(VP8Encoder* const enc) {
const int EXT_SIZE = 4;
const int kTrailerSize = 8;
uint8_t buffer[kTrailerSize];
VP8BitWriter* const bw = &enc->bw_;
uint8_t trailer[EXT_SIZE];
uint32_t ext_size = 0;
uint8_t ext_bits = 0x01;
if (enc->alpha_data_size_) {
// Layer (bytes 0..3)
PutLE24(buffer + 0, enc->layer_data_size_);
buffer[3] = enc->pic_->colorspace & WEBP_CSP_UV_MASK;
if (enc->layer_data_size_ > 0) {
assert(enc->use_layer_);
// append layer data to last partition
if (!VP8BitWriterAppend(&enc->parts_[enc->num_parts_ - 1],
enc->layer_data_, enc->layer_data_size_)) {
return 0;
}
}
// Alpha (bytes 4..6)
PutLE24(buffer + 4, enc->alpha_data_size_);
if (enc->alpha_data_size_ > 0) {
assert(enc->has_alpha_);
if (!VP8BitWriterAppend(bw, enc->alpha_data_, enc->alpha_data_size_)) {
return 0;
}
ext_size += enc->alpha_data_size_;
ext_bits |= 0x02;
}
trailer[0] = (ext_size >> 16) & 0xff;
trailer[1] = (ext_size >> 8) & 0xff;
trailer[2] = (ext_size >> 0) & 0xff;
trailer[EXT_SIZE - 1] = ext_bits;
if (!VP8BitWriterAppend(bw, trailer, EXT_SIZE)) {
buffer[kTrailerSize - 1] = 0x01; // marker
if (!VP8BitWriterAppend(bw, buffer, kTrailerSize)) {
return 0;
}
return 1;
@ -187,7 +203,7 @@ static size_t GeneratePartition0(VP8Encoder* const enc) {
const int mb_size = enc->mb_w_ * enc->mb_h_;
uint64_t pos1, pos2, pos3;
#ifdef WEBP_EXPERIMENTAL_FEATURES
const int need_extensions = (enc->alpha_data_size_ > 0);
const int need_extensions = enc->has_alpha_ || enc->use_layer_;
#endif
pos1 = VP8BitWriterPos(bw);
@ -221,6 +237,7 @@ static size_t GeneratePartition0(VP8Encoder* const enc) {
enc->pic_->stats->header_bytes[0] = (int)((pos2 - pos1 + 7) >> 3);
enc->pic_->stats->header_bytes[1] = (int)((pos3 - pos2 + 7) >> 3);
enc->pic_->stats->alpha_data_size = enc->alpha_data_size_;
enc->pic_->stats->layer_data_size = enc->layer_data_size_;
}
return !bw->error_;
}

24
src/enc/vp8enci.h
View File

@ -13,7 +13,7 @@
#define WEBP_ENC_VP8ENCI_H_
#include "string.h" // for memcpy()
#include "webp/encode.h"
#include "../webp/encode.h"
#include "bit_writer.h"
#if defined(__cplusplus) || defined(c_plusplus)
@ -330,9 +330,16 @@ struct VP8Encoder {
VP8BitWriter parts_[MAX_NUM_PARTITIONS]; // token partitions
// transparency blob
uint8_t* alpha_data_;
int has_alpha_;
uint8_t* alpha_data_; // non-NULL if transparency is present
size_t alpha_data_size_;
// enhancement layer
int use_layer_;
VP8BitWriter layer_bw_;
uint8_t* layer_data_;
size_t layer_data_size_;
// quantization info (one set of DC/AC dequant factor per segment)
VP8SegmentInfo dqm_[NUM_MB_SEGMENTS];
int base_quant_; // nominal quantizer value. Only used
@ -427,9 +434,16 @@ void VP8SetSegmentParams(VP8Encoder* const enc, float quality);
int VP8Decimate(VP8EncIterator* const it, VP8ModeScore* const rd, int rd_opt);
// in alpha.c
// Compress transparency information into enc->alpha_data_. Return true if ok.
int VP8EncProcessAlpha(VP8Encoder* enc);
void VP8EncDeleteAlpha(VP8Encoder* enc); // delete compressed data
void VP8EncInitAlpha(VP8Encoder* enc); // initialize alpha compression
void VP8EncCodeAlphaBlock(VP8EncIterator* it); // analyze or code a macroblock
int VP8EncFinishAlpha(VP8Encoder* enc); // finalize compressed data
void VP8EncDeleteAlpha(VP8Encoder* enc); // delete compressed data
// in layer.c
void VP8EncInitLayer(VP8Encoder* const enc); // init everything
void VP8EncCodeLayerBlock(VP8EncIterator* it); // code one more macroblock
int VP8EncFinishLayer(VP8Encoder* const enc); // finalize coding
void VP8EncDeleteLayer(VP8Encoder* enc); // reclaim memory
// in dsp.c
// Transforms

13
src/enc/webpenc.c
View File

@ -242,12 +242,20 @@ static VP8Encoder* InitEncoder(const WebPConfig* const config,
ResetFilterHeader(enc);
ResetBoundaryPredictions(enc);
#ifdef WEBP_EXPERIMENTAL_FEATURES
VP8EncInitAlpha(enc);
VP8EncInitLayer(enc);
#endif
return enc;
}
static void DeleteEncoder(VP8Encoder* enc) {
if (enc) {
#ifdef WEBP_EXPERIMENTAL_FEATURES
VP8EncDeleteAlpha(enc);
VP8EncDeleteLayer(enc);
#endif
free(enc);
}
}
@ -309,7 +317,10 @@ int WebPEncode(const WebPConfig* const config, WebPPicture* const pic) {
ok = VP8EncAnalyze(enc)
&& VP8StatLoop(enc)
&& VP8EncLoop(enc)
&& VP8EncProcessAlpha(enc)
#ifdef WEBP_EXPERIMENTAL_FEATURES
&& VP8EncFinishAlpha(enc)
&& VP8EncFinishLayer(enc)
#endif
&& VP8EncWrite(enc);
StoreStats(enc);
DeleteEncoder(enc);

2
src/webp/decode.h
View File

@ -12,7 +12,7 @@
#ifndef WEBP_WEBP_DECODE_H_
#define WEBP_WEBP_DECODE_H_
#include "webp/types.h"
#include "./types.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

2
src/webp/decode_vp8.h
View File

@ -12,7 +12,7 @@
#ifndef WEBP_WEBP_DECODE_VP8_H_
#define WEBP_WEBP_DECODE_VP8_H_
#include "webp/decode.h"
#include "./decode.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {

35
src/webp/encode.h
View File

@ -14,7 +14,7 @@
#include <stdlib.h>
#include "webp/types.h"
#include "./types.h"
#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
@ -122,6 +122,7 @@ typedef struct {
int segment_level[4]; // filtering strength for each segments [0..63]
int alpha_data_size; // size of the transparency data
int layer_data_size; // size of the enhancement layer data
} WebPAuxStats;
// Signature for output function. Should return 1 if writing was successful.
@ -130,9 +131,24 @@ typedef struct {
typedef int (*WebPWriterFunction)(const uint8_t* data, size_t data_size,
const WebPPicture* const picture);
typedef enum {
// chroma sampling
WEBP_YUV420 = 0, // 4:2:0
WEBP_YUV422 = 1, // 4:2:2
WEBP_YUV444 = 2, // 4:4:4
WEBP_YUV400 = 3, // grayscale
WEBP_CSP_UV_MASK = 3, // bit-mask to get the UV sampling factors
// alpha channel variants
WEBP_YUV420A = 4,
WEBP_YUV422A = 5,
WEBP_YUV444A = 6,
WEBP_YUV400A = 7, // grayscale + alpha
WEBP_CSP_ALPHA_BIT = 4 // bit that is set if alpha is present
} WebPEncCSP;
struct WebPPicture {
// input
int colorspace; // colorspace: should be 0 for now (=Y'CbCr).
WebPEncCSP colorspace; // colorspace: should be YUV420 for now (=Y'CbCr).
int width, height; // dimensions.
uint8_t *y, *u, *v; // pointers to luma/chroma planes.
int y_stride, uv_stride; // luma/chroma strides.
@ -155,6 +171,10 @@ struct WebPPicture {
// where to store statistics, if not NULL:
WebPAuxStats* stats;
// original samples (for non-YUV420 modes)
uint8_t *u0, *v0;
int uv0_stride;
};
// Internal, version-checked, entry point
@ -171,15 +191,11 @@ static inline int WebPPictureInit(WebPPicture* const picture) {
// WebPPicture utils
// Convenience allocation / deallocation based on picture->width/height:
// Allocate y/u/v buffers as per width/height specification.
// Allocate y/u/v buffers as per colorspace/width/height specification.
// Note! This function will free the previous buffer if needed.
// Returns 0 in case of memory error.
int WebPPictureAlloc(WebPPicture* const picture);
// This function will add storage for a transparency plane to a picture, using
// its width and depth.
int WebPPictureAddAlphaPlane(WebPPicture* const picture);
// Release memory allocated by WebPPictureAlloc() or WebPPictureImport*()
// Note that this function does _not_ free the memory pointed to by 'picture'.
void WebPPictureFree(WebPPicture* const picture);
@ -194,6 +210,11 @@ int WebPPictureCopy(const WebPPicture* const src, WebPPicture* const dst);
int WebPPictureCrop(WebPPicture* const picture,
int left, int top, int width, int height);
// Rescale a picture to new dimension width x height.
// Now gamma correction is applied.
// Returns false in case of error (invalid parameter or insufficient memory).
int WebPPictureRescale(WebPPicture* const pic, int width, int height);
// Colorspace conversion function to import RGB samples.
// Previous buffer will be free'd, if any.
// *rgb buffer should have a size of at least height * rgb_stride.