diff --git a/makefile.unix b/makefile.unix index 09c09deb..58d266f3 100644 --- a/makefile.unix +++ b/makefile.unix @@ -44,7 +44,8 @@ OBJS = src/enc/webpenc.o src/enc/bit_writer.o src/enc/syntax.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/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/quant.o src/dec/tree.o src/dec/vp8.o src/dec/yuv.o \ + src/dec/idec.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 diff --git a/src/Makefile.in b/src/Makefile.in index 616e6b83..353a76b8 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -249,7 +249,7 @@ top_srcdir = @top_srcdir@ SUBDIRS = dec enc AM_CPPFLAGS = -I$(top_srcdir)/src lib_LTLIBRARIES = libwebp.la -libwebp_la_SOURCES = +libwebp_la_SOURCES = libwebp_la_LIBADD = dec/libwebpdecode.la \ enc/libwebpencode.la @@ -322,7 +322,7 @@ clean-libLTLIBRARIES: echo "rm -f \"$${dir}/so_locations\""; \ rm -f "$${dir}/so_locations"; \ done -libwebp.la: $(libwebp_la_OBJECTS) $(libwebp_la_DEPENDENCIES) +libwebp.la: $(libwebp_la_OBJECTS) $(libwebp_la_DEPENDENCIES) $(libwebp_la_LINK) -rpath $(libdir) $(libwebp_la_OBJECTS) $(libwebp_la_LIBADD) $(LIBS) mostlyclean-compile: diff --git a/src/dec/Makefile.am b/src/dec/Makefile.am index b01b0d98..835141a3 100644 --- a/src/dec/Makefile.am +++ b/src/dec/Makefile.am @@ -1,7 +1,7 @@ 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 + quant.c tree.c vp8.c webp.c yuv.c idec.c libwebpdecode_la_LDFLAGS = -version-info 0:0:0 libwebpdecodeinclude_HEADERS = ../webp/decode.h ../webp/decode_vp8.h ../webp/types.h libwebpdecodeincludedir = $(includedir)/webp diff --git a/src/dec/Makefile.in b/src/dec/Makefile.in index 898133dd..5087b87c 100644 --- a/src/dec/Makefile.in +++ b/src/dec/Makefile.in @@ -49,7 +49,7 @@ CONFIG_CLEAN_VPATH_FILES = LTLIBRARIES = $(noinst_LTLIBRARIES) libwebpdecode_la_LIBADD = am_libwebpdecode_la_OBJECTS = bits.lo dsp.lo frame.lo quant.lo tree.lo \ - vp8.lo webp.lo yuv.lo + vp8.lo webp.lo yuv.lo idec.lo libwebpdecode_la_OBJECTS = $(am_libwebpdecode_la_OBJECTS) libwebpdecode_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ @@ -213,7 +213,7 @@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ 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 + quant.c tree.c vp8.c webp.c yuv.c idec.c libwebpdecode_la_LDFLAGS = -version-info 0:0:0 libwebpdecodeinclude_HEADERS = ../webp/decode.h ../webp/decode_vp8.h ../webp/types.h @@ -263,7 +263,7 @@ clean-noinstLTLIBRARIES: echo "rm -f \"$${dir}/so_locations\""; \ rm -f "$${dir}/so_locations"; \ done -libwebpdecode.la: $(libwebpdecode_la_OBJECTS) $(libwebpdecode_la_DEPENDENCIES) +libwebpdecode.la: $(libwebpdecode_la_OBJECTS) $(libwebpdecode_la_DEPENDENCIES) $(libwebpdecode_la_LINK) $(libwebpdecode_la_OBJECTS) $(libwebpdecode_la_LIBADD) $(LIBS) mostlyclean-compile: @@ -275,6 +275,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bits.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dsp.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/frame.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/idec.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/quant.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/tree.Plo@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vp8.Plo@am__quote@ diff --git a/src/dec/idec.c b/src/dec/idec.c new file mode 100644 index 00000000..b13d908a --- /dev/null +++ b/src/dec/idec.c @@ -0,0 +1,567 @@ +// 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/ +// ----------------------------------------------------------------------------- +// +// Incremental decoding +// +// Author: somnath@google.com (Somnath Banerjee) + +#include +#include +#include + +#include "webpi.h" +#include "vp8i.h" +#include "yuv.h" + +#define RIFF_HEADER_SIZE 20 +#define VP8_HEADER_SIZE 10 +#define WEBP_HEADER_SIZE (RIFF_HEADER_SIZE + VP8_HEADER_SIZE) +#define CHUNK_SIZE 4096 +#define MAX_MB_SIZE 4096 + +//------------------------------------------------------------------------------ +// Data structures for memory and states + +// Decoding states. State normally flows like HEADER->PARTS0->DATA->DONE. +// If there is any error the decoder goes into state ERROR. +typedef enum { STATE_HEADER = 0, STATE_PARTS0 = 1, + STATE_DATA = 2, STATE_DONE = 3, + STATE_ERROR = 4 +} DecState; + +// Operating state for the MemBuffer +typedef enum { MEM_MODE_NONE = 0, + MEM_MODE_APPEND, MEM_MODE_MAP +} MemBufferMode; + +// storage for partition #0 and partial data (in a rolling fashion) +typedef struct { + MemBufferMode mode_; // Operation mode + uint32_t start_; // start location of the data to be decoded + uint32_t end_; // end location + size_t buf_size_; // size of the allocated buffer + uint8_t* buf_; // We don't own this buffer in case WebPIUpdate() + + size_t part0_size_; // size of partition #0 + const uint8_t* part0_buf_; // buffer to store partition #0 +} MemBuffer; + +struct WebPIDecoder { + DecState state_; // current decoding state + int w_, h_; // width and height + WebPDecParams params_; // Params to store output info + VP8Decoder* dec_; + VP8Io io_; + + MemBuffer mem_; // memory buffer +}; + +// MB context to restore in case VP8DecodeMB() fails +typedef struct { + VP8MB left_; + VP8MB info_; + uint8_t intra_t_[4]; + uint8_t intra_l_[4]; + VP8BitReader br_; + VP8BitReader token_br_; +} MBContext; + +//------------------------------------------------------------------------------ +// MemBuffer: incoming data handling + +#define REMAP(PTR, OLD_BASE, NEW_BASE) (PTR) = (NEW_BASE) + ((PTR) - OLD_BASE) + +static inline size_t MemDataSize(const MemBuffer* mem) { + return (mem->end_ - mem->start_); +} + +// Appends data to the end of MemBuffer->buf_. It expands the allocated memory +// size if required and also updates VP8BitReader's if new memory is allocated. +static int AppendToMemBuffer(WebPIDecoder* const idec, + const uint8_t* const data, size_t data_size) { + MemBuffer* const mem = &idec->mem_; + VP8Decoder* const dec = idec->dec_; + const int last_part = dec->num_parts_ - 1; + assert(mem->mode_ == MEM_MODE_APPEND); + + if (mem->end_ + data_size > mem->buf_size_) { // Need some free memory + int p; + uint8_t* new_buf = NULL; + const int num_chunks = (MemDataSize(mem) + data_size + CHUNK_SIZE - 1) + / CHUNK_SIZE; + const size_t new_size = num_chunks * CHUNK_SIZE; + const uint8_t* const base = mem->buf_ + mem->start_; + + new_buf = (uint8_t*)malloc(new_size); + if (!new_buf) return 0; + memcpy(new_buf, base, MemDataSize(mem)); + + // adjust VP8BitReader pointers + for (p = 0; p <= last_part; ++p) { + if (dec->parts_[p].buf_) { + REMAP(dec->parts_[p].buf_, base, new_buf); + REMAP(dec->parts_[p].buf_end_, base, new_buf); + } + } + + // adjust memory pointers + free(mem->buf_); + mem->buf_ = new_buf; + mem->buf_size_ = new_size; + + mem->end_ = MemDataSize(mem); + mem->start_ = 0; + } + + memcpy(mem->buf_ + mem->end_, data, data_size); + mem->end_ += data_size; + assert(mem->end_ <= mem->buf_size_); + dec->parts_[last_part].buf_end_ = mem->buf_ + mem->end_; + + // note: setting up idec->io_ is only really needed at the beginning + // of the decoding, till partition #0 is complete. + idec->io_.data = mem->buf_ + mem->start_; + idec->io_.data_size = MemDataSize(mem); + return 1; +} + +static int RemapMemBuffer(WebPIDecoder* const idec, + const uint8_t* const data, size_t data_size) { + int p; + MemBuffer* const mem = &idec->mem_; + VP8Decoder* const dec = idec->dec_; + const int last_part = dec->num_parts_ - 1; + const uint8_t* base = mem->buf_; + + assert(mem->mode_ == MEM_MODE_MAP); + if (data_size < mem->buf_size_) { + return 0; // we cannot remap to a shorter buffer! + } + + for (p = 0; p <= last_part; ++p) { + if (dec->parts_[p].buf_) { + REMAP(dec->parts_[p].buf_, base, data); + REMAP(dec->parts_[p].buf_end_, base, data); + } + } + dec->parts_[last_part].buf_end_ = data + data_size; + + // Remap partition #0 data pointer to new offset. + if (dec->br_.buf_) { + REMAP(dec->br_.buf_, base, data); + REMAP(dec->br_.buf_end_, base, data); + } + + mem->buf_ = (uint8_t*)data; + mem->end_ = mem->buf_size_ = data_size; + + idec->io_.data = data; + idec->io_.data_size = data_size; + return 1; +} + +static void InitMemBuffer(MemBuffer* const mem) { + mem->mode_ = MEM_MODE_NONE; + mem->buf_ = 0; + mem->buf_size_ = 0; + mem->part0_buf_ = 0; + mem->part0_size_ = 0; +} + +static void ClearMemBuffer(MemBuffer* const mem) { + assert(mem); + if (mem->mode_ == MEM_MODE_APPEND) { + free(mem->buf_); + free((void*)mem->part0_buf_); + } +} + +static int CheckMemBufferMode(MemBuffer* const mem, MemBufferMode expected) { + if (mem->mode_ == MEM_MODE_NONE) { + mem->mode_ = expected; // switch to the expected mode + } else if (mem->mode_ != expected) { + return 0; // we mixed the modes => error + } + assert(mem->mode_ == expected); // mode is ok + return 1; +} + +#undef REMAP + +//------------------------------------------------------------------------------ +// Macroblock-decoding contexts + +static void SaveContext(const VP8Decoder* dec, const VP8BitReader* token_br, + MBContext* const context) { + const VP8BitReader* const br = &dec->br_; + const VP8MB* const left = dec->mb_info_ - 1; + const VP8MB* const info = dec->mb_info_ + dec->mb_x_; + + context->left_ = *left; + context->info_ = *info; + context->br_ = *br; + context->token_br_ = *token_br; + memcpy(context->intra_t_, dec->intra_t_ + 4 * dec->mb_x_, 4); + memcpy(context->intra_l_, dec->intra_l_, 4); +} + +static void RestoreContext(const MBContext* context, VP8Decoder* const dec, + VP8BitReader* const token_br) { + VP8BitReader* const br = &dec->br_; + VP8MB* const left = dec->mb_info_ - 1; + VP8MB* const info = dec->mb_info_ + dec->mb_x_; + + *left = context->left_; + *info = context->info_; + *br = context->br_; + *token_br = context->token_br_; + memcpy(dec->intra_t_ + 4 * dec->mb_x_, context->intra_t_, 4); + memcpy(dec->intra_l_, context->intra_l_, 4); +} + +//------------------------------------------------------------------------------ + +static VP8StatusCode IDecError(WebPIDecoder* idec, VP8StatusCode error) { + idec->state_ = STATE_ERROR; + return error; +} + +// Header +static VP8StatusCode DecodeHeader(WebPIDecoder* const idec) { + int width, height; + uint32_t curr_size, riff_header_size, bits; + WebPDecParams* params = &idec->params_; + const uint8_t* data = idec->mem_.buf_ + idec->mem_.start_; + + if (MemDataSize(&idec->mem_) < WEBP_HEADER_SIZE) { + return VP8_STATUS_SUSPENDED; + } + + if (!WebPInitDecParams(data, idec->mem_.end_, &width, &height, params)) { + return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR); + } + + // Validate and Skip over RIFF header + curr_size = MemDataSize(&idec->mem_); + if (!WebPCheckRIFFHeader(&data, &curr_size)) { + return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR); + } + riff_header_size = idec->mem_.end_ - curr_size; + bits = data[0] | (data[1] << 8) | (data[2] << 16); + + idec->mem_.part0_size_ = (bits >> 5) + VP8_HEADER_SIZE; + idec->mem_.start_ += riff_header_size; + assert(idec->mem_.start_ <= idec->mem_.end_); + + idec->w_ = width; + idec->h_ = height; + idec->io_.data_size -= riff_header_size; + idec->io_.data = data; + idec->state_ = STATE_PARTS0; + return VP8_STATUS_OK; +} + +// Partition #0 +static int CopyParts0Data(WebPIDecoder* idec) { + VP8BitReader* const br = &idec->dec_->br_; + const size_t psize = br->buf_end_ - br->buf_; + MemBuffer* const mem = &idec->mem_; + assert(!mem->part0_buf_); + assert(psize > 0); + assert(psize <= mem->part0_size_); + if (mem->mode_ == MEM_MODE_APPEND) { + // We copy and grab ownership of the partition #0 data. + uint8_t* const part0_buf = (uint8_t*)malloc(psize); + if (!part0_buf) { + return 0; + } + memcpy(part0_buf, br->buf_, psize); + mem->part0_buf_ = part0_buf; + mem->start_ += psize; + br->buf_ = part0_buf; + br->buf_end_ = part0_buf + psize; + } else { + // Else: just keep pointers to the partition #0's data in dec_->br_. + } + return 1; +} + +static VP8StatusCode DecodePartition0(WebPIDecoder* const idec) { + VP8Decoder* const dec = idec->dec_; + VP8Io* const io = &idec->io_; + const WebPDecParams* const params = &idec->params_; + const WEBP_CSP_MODE mode = params->mode; + + // Wait till we have enough data for the whole partition #0 + if (MemDataSize(&idec->mem_) < idec->mem_.part0_size_) { + return VP8_STATUS_SUSPENDED; + } + + io->opaque = &idec->params_; + if (!VP8GetHeaders(dec, io)) { + const VP8StatusCode status = dec->status_; + if (status == VP8_STATUS_SUSPENDED || + status == VP8_STATUS_NOT_ENOUGH_DATA) { + // treating NOT_ENOUGH_DATA as SUSPENDED state + return VP8_STATUS_SUSPENDED; + } + return IDecError(idec, status); + } + + if (!WebPCheckDecParams(io, params)) { + return IDecError(idec, VP8_STATUS_INVALID_PARAM); + } + + if (mode != MODE_YUV) { + VP8YUVInit(); + } + + // allocate memory and prepare everything. + if (!VP8InitFrame(dec, io)) { + return IDecError(idec, VP8_STATUS_OUT_OF_MEMORY); + } + if (io->setup && !io->setup(io)) { + return IDecError(idec, VP8_STATUS_USER_ABORT); + } + + // disable filtering per user request (_after_ setup() is called) + if (io->bypass_filtering) dec->filter_type_ = 0; + + if (!CopyParts0Data(idec)) { + return IDecError(idec, VP8_STATUS_OUT_OF_MEMORY); + } + + idec->state_ = STATE_DATA; + return VP8_STATUS_OK; +} + +// Remaining partitions +static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) { + VP8BitReader* br; + VP8Decoder* const dec = idec->dec_; + VP8Io* const io = &idec->io_; + + assert(dec->ready_); + + br = &dec->br_; + for (; dec->mb_y_ < dec->mb_h_; ++dec->mb_y_) { + VP8BitReader* token_br = &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)]; + if (dec->mb_x_ == 0) { + VP8MB* const left = dec->mb_info_ - 1; + left->nz_ = 0; + left->dc_nz_ = 0; + memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_)); + } + + for (; dec->mb_x_ < dec->mb_w_; dec->mb_x_++) { + MBContext context; + SaveContext(dec, token_br, &context); + + if (!VP8DecodeMB(dec, token_br)) { + RestoreContext(&context, dec, token_br); + // We shouldn't fail when MAX_MB data was available + if (dec->num_parts_ == 1 && MemDataSize(&idec->mem_) > MAX_MB_SIZE) { + return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR); + } + return VP8_STATUS_SUSPENDED; + } + VP8ReconstructBlock(dec); + // Store data and save block's filtering params + VP8StoreBlock(dec); + + // Release buffer only if there is only one partition + if (dec->num_parts_ == 1) { + idec->mem_.start_ = token_br->buf_ - idec->mem_.buf_; + assert(idec->mem_.start_ <= idec->mem_.end_); + } + } + if (!VP8FinishRow(dec, io)) { + return IDecError(idec, VP8_STATUS_USER_ABORT); + } + dec->mb_x_ = 0; + } + + if (io->teardown) { + io->teardown(io); + } + dec->ready_ = 0; + idec->state_ = STATE_DONE; + + return VP8_STATUS_OK; +} + + // Main decoding loop +static VP8StatusCode IDecode(WebPIDecoder* idec) { + VP8StatusCode status = VP8_STATUS_SUSPENDED; + assert(idec->dec_); + + if (idec->state_ == STATE_HEADER) { + status = DecodeHeader(idec); + } + if (idec->state_ == STATE_PARTS0) { + status = DecodePartition0(idec); + } + if (idec->state_ == STATE_DATA) { + return DecodeRemaining(idec); + } + return status; +} + +//------------------------------------------------------------------------------ +// Public functions + +WebPIDecoder* WebPINew(WEBP_CSP_MODE mode) { + WebPIDecoder* idec = (WebPIDecoder*)calloc(1, sizeof(WebPIDecoder)); + if (!idec) return NULL; + + idec->dec_ = VP8New(); + if (idec->dec_ == NULL) { + free(idec); + return NULL; + } + + idec->state_ = STATE_HEADER; + idec->params_.mode = mode; + + InitMemBuffer(&idec->mem_); + VP8InitIo(&idec->io_); + WebPInitCustomIo(&idec->io_); + return idec; +} + +void WebPIDelete(WebPIDecoder* const idec) { + if (!idec) return; + VP8Delete(idec->dec_); + WebPClearDecParams(&idec->params_); + ClearMemBuffer(&idec->mem_); + free(idec); +} + +//------------------------------------------------------------------------------ + +WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE mode, uint8_t* output_buffer, + int output_buffer_size, int output_stride) { + WebPIDecoder* idec; + if (mode == MODE_YUV) return NULL; + idec = WebPINew(mode); + if (idec == NULL) return NULL; + idec->params_.output = output_buffer; + idec->params_.stride = output_stride; + idec->params_.output_size = output_buffer_size; + idec->params_.external_buffer = 1; + return idec; +} + +WebPIDecoder* WebPINewYUV(uint8_t* luma, int luma_size, int luma_stride, + uint8_t* u, int u_size, int u_stride, + uint8_t* v, int v_size, int v_stride) { + WebPIDecoder* idec = WebPINew(MODE_YUV); + if (idec == NULL) return NULL; + idec->params_.output = luma; + idec->params_.stride = luma_stride; + idec->params_.output_size = luma_size; + idec->params_.u = u; + idec->params_.u_stride = u_stride; + idec->params_.output_u_size = u_size; + idec->params_.v = v; + idec->params_.v_stride = v_stride; + idec->params_.output_v_size = v_size; + idec->params_.external_buffer = 1; + return idec; +} + +//------------------------------------------------------------------------------ + +static VP8StatusCode IDecCheckStatus(const WebPIDecoder* const idec) { + assert(idec); + if (idec->dec_ == NULL) { + return VP8_STATUS_USER_ABORT; + } + if (idec->state_ == STATE_ERROR) { + return VP8_STATUS_BITSTREAM_ERROR; + } + if (idec->state_ == STATE_DONE) { + return VP8_STATUS_OK; + } + return VP8_STATUS_SUSPENDED; +} + +VP8StatusCode WebPIAppend(WebPIDecoder* const idec, const uint8_t* data, + uint32_t data_size) { + if (idec == NULL || data == NULL) { + return VP8_STATUS_INVALID_PARAM; + } + const VP8StatusCode status = IDecCheckStatus(idec); + if (status != VP8_STATUS_SUSPENDED) { + return status; + } + // Check mixed calls between RemapMemBuffer and AppendToMemBuffer. + if (!CheckMemBufferMode(&idec->mem_, MEM_MODE_APPEND)) { + return VP8_STATUS_INVALID_PARAM; + } + // Append data to memory buffer + if (!AppendToMemBuffer(idec, data, data_size)) { + return VP8_STATUS_OUT_OF_MEMORY; + } + return IDecode(idec); +} + +VP8StatusCode WebPIUpdate(WebPIDecoder* const idec, const uint8_t* data, + uint32_t data_size) { + if (idec == NULL || data == NULL) { + return VP8_STATUS_INVALID_PARAM; + } + const VP8StatusCode status = IDecCheckStatus(idec); + if (status != VP8_STATUS_SUSPENDED) { + return status; + } + // Check mixed calls between RemapMemBuffer and AppendToMemBuffer. + if (!CheckMemBufferMode(&idec->mem_, MEM_MODE_MAP)) { + return VP8_STATUS_INVALID_PARAM; + } + // Make the memory buffer point to the new buffer + if (!RemapMemBuffer(idec, data, data_size)) { + return VP8_STATUS_INVALID_PARAM; + } + return IDecode(idec); +} + +//------------------------------------------------------------------------------ + +uint8_t* WebPIDecGetRGB(const WebPIDecoder* idec, int *last_y, + int* width, int* height, int* stride) { + if (!idec || !idec->dec_ || idec->params_.mode != MODE_RGB || + idec->state_ <= STATE_PARTS0) { + return NULL; + } + + if (last_y) *last_y = idec->params_.last_y; + if (width) *width = idec->w_; + if (height) *height = idec->h_; + if (stride) *stride = idec->params_.stride; + + return idec->params_.output; +} + +uint8_t* WebPIDecGetYUV(const WebPIDecoder* idec, int *last_y, uint8_t** u, + uint8_t** v, int* width, int* height, int *stride, + int* uv_stride) { + if (!idec || !idec->dec_ || idec->params_.mode != MODE_YUV || + idec->state_ <= STATE_PARTS0) { + return NULL; + } + + if (last_y) *last_y = idec->params_.last_y; + if (u) *u = idec->params_.u; + if (v) *v = idec->params_.v; + if (width) *width = idec->w_; + if (height) *height = idec->h_; + if (stride) *stride = idec->params_.stride; + if (uv_stride) *uv_stride = idec->params_.u_stride; + + return idec->params_.output; +} diff --git a/src/dec/tree.c b/src/dec/tree.c index 9c7074bb..ed6caad2 100644 --- a/src/dec/tree.c +++ b/src/dec/tree.c @@ -9,7 +9,6 @@ // // Author: Skal (pascal.massimino@gmail.com) -#include #include "vp8i.h" #define USE_GENERIC_TREE diff --git a/src/dec/webp.c b/src/dec/webp.c index 7ba0ffcb..d51a066a 100644 --- a/src/dec/webp.c +++ b/src/dec/webp.c @@ -319,12 +319,7 @@ void WebPInitCustomIo(VP8Io* const io) { int WebPInitDecParams(const uint8_t* data, uint32_t data_size, int* width, int* height, WebPDecParams* const params) { - int w, h, stride; - int uv_size = 0; - int uv_stride = 0; - int size; - uint8_t* output; - WEBP_CSP_MODE mode = params->mode; + int w, h; if (!WebPGetInfo(data, data_size, &w, &h)) { return 0; @@ -332,38 +327,49 @@ int WebPInitDecParams(const uint8_t* data, uint32_t data_size, int* width, if (width) *width = w; if (height) *height = h; - // initialize output buffer, now that dimensions are known. - stride = (mode == MODE_RGB || mode == MODE_BGR) ? 3 * w - : (mode == MODE_RGBA || mode == MODE_BGRA) ? 4 * w - : w; - size = stride * h; + if (!params->external_buffer) { + int stride; + int uv_stride = 0; + int size; + int uv_size = 0; + uint8_t* output; + WEBP_CSP_MODE mode = params->mode; - if (mode == MODE_YUV) { - uv_stride = (w + 1) / 2; - uv_size = uv_stride * ((h + 1) / 2); - } + // initialize output buffer, now that dimensions are known. + stride = (mode == MODE_RGB || mode == MODE_BGR) ? 3 * w + : (mode == MODE_RGBA || mode == MODE_BGRA) ? 4 * w + : w; + size = stride * h; - output = (uint8_t*)malloc(size + 2 * uv_size); - if (!output) { - return 0; - } + if (mode == MODE_YUV) { + uv_stride = (w + 1) / 2; + uv_size = uv_stride * ((h + 1) / 2); + } - params->output = output; - params->stride = stride; - if (mode == MODE_YUV) { - params->u = output + size; - params->u_stride = uv_stride; - params->v = output + size + uv_size; - params->v_stride = uv_stride; + output = (uint8_t*)malloc(size + 2 * uv_size); + if (!output) { + return 0; + } + + params->output = output; + params->stride = stride; + params->output_size = size; + if (mode == MODE_YUV) { + params->u = output + size; + params->u_stride = uv_stride; + params->output_u_size = uv_size; + params->v = output + size + uv_size; + params->v_stride = uv_stride; + params->output_v_size = uv_size; + } } return 1; } -int WebPCheckDecParams(const VP8Io* io, const WebPDecParams* params, - int output_size, int output_u_size, int output_v_size) { +int WebPCheckDecParams(const VP8Io* io, const WebPDecParams* params) { int ok = 1; WEBP_CSP_MODE mode = params->mode; - ok &= (params->stride * io->height <= output_size); + ok &= (params->stride * io->height <= params->output_size); if (mode == MODE_RGB || mode == MODE_BGR) { ok &= (params->stride >= io->width * 3); } else if (mode == MODE_RGBA || mode == MODE_BGRA) { @@ -375,13 +381,16 @@ int WebPCheckDecParams(const VP8Io* io, const WebPDecParams* params, ok &= (params->stride >= io->width); ok &= (params->u_stride >= (io->width + 1) / 2) && (params->v_stride >= (io->width + 1) / 2); - ok &= (u_size <= output_u_size && v_size <= output_v_size); + ok &= (u_size <= params->output_u_size && + v_size <= params->output_v_size); } return ok; } void WebPClearDecParams(WebPDecParams* params) { - free(params->output); + if (!params->external_buffer) { + free(params->output); + } memset(params, 0, sizeof(*params)); } @@ -390,8 +399,7 @@ void WebPClearDecParams(WebPDecParams* params) { static uint8_t* DecodeInto(WEBP_CSP_MODE mode, const uint8_t* data, uint32_t data_size, - WebPDecParams* params, int output_size, - int output_u_size, int output_v_size) { + WebPDecParams* params) { VP8Decoder* dec = VP8New(); VP8Io io; int ok = 1; @@ -414,8 +422,7 @@ static uint8_t* DecodeInto(WEBP_CSP_MODE mode, } // check output buffers - ok = WebPCheckDecParams(&io, params, output_size, - output_u_size, output_v_size); + ok = WebPCheckDecParams(&io, params); if (!ok) { VP8Delete(dec); return NULL; @@ -441,7 +448,10 @@ uint8_t* WebPDecodeRGBInto(const uint8_t* data, uint32_t data_size, params.output = output; params.stride = output_stride; - return DecodeInto(MODE_RGB, data, data_size, ¶ms, output_size, 0, 0); + params.output_size = output_size; + params.output_u_size = 0; + params.output_v_size = 0; + return DecodeInto(MODE_RGB, data, data_size, ¶ms); } uint8_t* WebPDecodeRGBAInto(const uint8_t* data, uint32_t data_size, @@ -455,7 +465,10 @@ uint8_t* WebPDecodeRGBAInto(const uint8_t* data, uint32_t data_size, params.output = output; params.stride = output_stride; - return DecodeInto(MODE_RGBA, data, data_size, ¶ms, output_size, 0, 0); + params.output_size = output_size; + params.output_u_size = 0; + params.output_v_size = 0; + return DecodeInto(MODE_RGBA, data, data_size, ¶ms); } uint8_t* WebPDecodeBGRInto(const uint8_t* data, uint32_t data_size, @@ -469,7 +482,10 @@ uint8_t* WebPDecodeBGRInto(const uint8_t* data, uint32_t data_size, params.output = output; params.stride = output_stride; - return DecodeInto(MODE_BGR, data, data_size, ¶ms, output_size, 0, 0); + params.output_size = output_size; + params.output_u_size = 0; + params.output_v_size = 0; + return DecodeInto(MODE_BGR, data, data_size, ¶ms); } uint8_t* WebPDecodeBGRAInto(const uint8_t* data, uint32_t data_size, @@ -483,7 +499,10 @@ uint8_t* WebPDecodeBGRAInto(const uint8_t* data, uint32_t data_size, params.output = output; params.stride = output_stride; - return DecodeInto(MODE_BGRA, data, data_size, ¶ms, output_size, 0, 0); + params.output_size = output_size; + params.output_u_size = 0; + params.output_v_size = 0; + return DecodeInto(MODE_BGRA, data, data_size, ¶ms); } uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size, @@ -498,12 +517,14 @@ uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size, params.output = luma; params.stride = luma_stride; + params.output_size = luma_size; params.u = u; params.u_stride = u_stride; + params.output_u_size = u_size; params.v = v; params.v_stride = v_stride; - return DecodeInto(MODE_YUV, data, data_size, ¶ms, - luma_size, u_size, v_size); + params.output_v_size = v_size; + return DecodeInto(MODE_YUV, data, data_size, ¶ms); } //----------------------------------------------------------------------------- @@ -511,8 +532,6 @@ uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size, static uint8_t* Decode(WEBP_CSP_MODE mode, const uint8_t* data, uint32_t data_size, int* width, int* height, WebPDecParams* params_out) { - int size = 0; - int uv_size = 0; uint8_t* output; WebPDecParams params = { 0 }; @@ -521,9 +540,10 @@ static uint8_t* Decode(WEBP_CSP_MODE mode, const uint8_t* data, return NULL; } - size = params.stride * (*height); - uv_size = params.u_stride * ((*height + 1) / 2); - output = DecodeInto(mode, data, data_size, ¶ms, size, uv_size, uv_size); + params.output_size = params.stride * (*height); + params.output_u_size = params.output_v_size = + params.u_stride * ((*height + 1) / 2); + output = DecodeInto(mode, data, data_size, ¶ms); if (!output) { WebPClearDecParams(¶ms); } diff --git a/src/dec/webpi.h b/src/dec/webpi.h index 0188861c..cf5bc0ef 100644 --- a/src/dec/webpi.h +++ b/src/dec/webpi.h @@ -18,20 +18,20 @@ extern "C" { #include "webp/decode_vp8.h" -typedef enum { MODE_RGB = 0, MODE_RGBA = 1, - MODE_BGR = 2, MODE_BGRA = 3, - MODE_YUV = 4 } WEBP_CSP_MODE; - - // Decoding output parameters. +// Decoding output parameters. typedef struct { uint8_t* output; // rgb(a) or luma - uint8_t *u, *v; - uint8_t *top_y, *top_u, *top_v; + uint8_t *u, *v; // chroma u/v + uint8_t *top_y, *top_u, *top_v; // cache for the fancy upscaler int stride; // rgb(a) stride or luma stride - int u_stride; - int v_stride; - WEBP_CSP_MODE mode; + int u_stride; // chroma-u stride + int v_stride; // chroma-v stride + WEBP_CSP_MODE mode; // rgb(a) or yuv int last_y; // coordinate of the line that was last output + int output_size; // size of 'output' buffer + int output_u_size; // size of 'u' buffer + int output_v_size; // size of 'v' buffer + int external_buffer; // If true, the output buffers are externally owned } WebPDecParams; // If a RIFF container is detected, validate it and skip over it. Returns @@ -50,8 +50,7 @@ int WebPInitDecParams(const uint8_t* data, uint32_t data_size, int* width, // Verifies various size configurations (e.g stride >= width, specified // output size <= stride * height etc.). Returns 0 if checks fail. -int WebPCheckDecParams(const VP8Io* io, const WebPDecParams* params, - int output_size, int output_u_size, int output_v_size); +int WebPCheckDecParams(const VP8Io* io, const WebPDecParams* params); // Deallocate memory allocated by WebPInitDecParams() and reset the // WebPDecParams object. diff --git a/src/webp/decode.h b/src/webp/decode.h index 7099fb20..fefab0a4 100644 --- a/src/webp/decode.h +++ b/src/webp/decode.h @@ -92,6 +92,100 @@ uint8_t* WebPDecodeYUVInto(const uint8_t* data, uint32_t data_size, //----------------------------------------------------------------------------- +// Output colorspaces +typedef enum { MODE_RGB = 0, MODE_RGBA = 1, + MODE_BGR = 2, MODE_BGRA = 3, + MODE_YUV = 4 } WEBP_CSP_MODE; + +// Enumeration of the status codes +typedef enum { + VP8_STATUS_OK = 0, + VP8_STATUS_OUT_OF_MEMORY, + VP8_STATUS_INVALID_PARAM, + VP8_STATUS_BITSTREAM_ERROR, + VP8_STATUS_UNSUPPORTED_FEATURE, + VP8_STATUS_SUSPENDED, + VP8_STATUS_USER_ABORT, + VP8_STATUS_NOT_ENOUGH_DATA +} VP8StatusCode; + +//----------------------------------------------------------------------------- +// Incremental decoding +// +// This API allows streamlined decoding of partial data. +// Picture can be incrementally decoded as data become available thanks to the +// WebPIDecoder object. This object can be left in a SUSPENDED state if the +// picture is only partially decoded, pending additional input. +// Code example: +// +// WebPIDecoder* const idec = WebPINew(mode); +// while (has_more_data) { +// // ... (get additional data) +// status = WebPIAppend(idec, new_data, new_data_size); +// if (status != VP8_STATUS_SUSPENDED || +// break; +// } +// +// // The above call decodes the current available buffer. +// // Part of the image can now be refreshed by calling to +// // WebPIDecGetRGB()/WebPIDecGetYUV() etc. +// } +// WebPIDelete(idec); + +typedef struct WebPIDecoder WebPIDecoder; + +// Creates a WebPIDecoder object. Returns NULL in case of failure. +WebPIDecoder* WebPINew(WEBP_CSP_MODE mode); + +// This function allocates and initializes an incremental-decoder object, which +// will output the r/g/b(/a) samples specified by 'mode' into a preallocated +// buffer 'output_buffer'. The size of this buffer is at least +// 'output_buffer_size' and the stride (distance in bytes between two scanlines) +// is specified by 'output_stride'. Returns NULL if the allocation failed. +WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE mode, uint8_t* output_buffer, + int output_buffer_size, int output_stride); + +// This function allocates and initializes an incremental-decoder object, which +// will output the raw luma/chroma samples into a preallocated planes. The luma +// plane is specified by its pointer 'luma', its size 'luma_size' and its stride +// 'luma_stride'. Similarly, the chroma-u plane is specified by the 'u', +// 'u_size' and 'u_stride' parameters, and the chroma-v plane by 'v', 'v_size' +// and 'v_size'. +// Returns NULL if the allocation failed. +WebPIDecoder* WebPINewYUV(uint8_t* luma, int luma_size, int luma_stride, + uint8_t* u, int u_size, int u_stride, + uint8_t* v, int v_size, int v_stride); + +// Deletes the WebpBuffer object and associated memory. Must always be called +// if WebPINew, WebPINewRGB or WebPINewYUV succeeded. +void WebPIDelete(WebPIDecoder* const idec); + +// Copies and decodes the next available data. Returns VP8_STATUS_OK when +// the image is successfully decoded. Returns VP8_STATUS_SUSPENDED when more +// data is expected. Returns error in other cases. +VP8StatusCode WebPIAppend(WebPIDecoder* const idec, const uint8_t* data, + uint32_t data_size); + +// A variant of the above function to be used when data buffer contains +// partial data from the beginning. In this case data buffer is not copied +// to the internal memory. +VP8StatusCode WebPIUpdate(WebPIDecoder* const idec, const uint8_t* data, + uint32_t data_size); + +// Returns the RGB image decoded so far. Returns NULL if output params are not +// initialized yet. *last_y is the index of last decoded row in raster scan +// order. Some pointers (*last_y, *width etc.) can be NULL if corresponding +// information is not needed. +uint8_t* WebPIDecGetRGB(const WebPIDecoder* const idec, int *last_y, + int* width, int* height, int* stride); + +// Same as above function to get YUV image. Returns pointer to the luma plane +// or NULL in case of error. +uint8_t* WebPIDecGetYUV(const WebPIDecoder* const idec, int* last_y, + uint8_t** u, uint8_t** v, + int* width, int* height, int* stride, int* uv_stride); + + #if defined(__cplusplus) || defined(c_plusplus) } // extern "C" #endif diff --git a/src/webp/decode_vp8.h b/src/webp/decode_vp8.h index 08c6f69b..efcf649d 100644 --- a/src/webp/decode_vp8.h +++ b/src/webp/decode_vp8.h @@ -12,7 +12,7 @@ #ifndef WEBP_WEBP_DECODE_VP8_H_ #define WEBP_WEBP_DECODE_VP8_H_ -#include "decode.h" +#include "webp/decode.h" #if defined(__cplusplus) || defined(c_plusplus) extern "C" { @@ -105,18 +105,6 @@ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io); // Returns false in case of error. int VP8Decode(VP8Decoder* const dec, VP8Io* const io); -// Enumeration of the codes returned by VP8Status() -typedef enum { - VP8_STATUS_OK = 0, - VP8_STATUS_OUT_OF_MEMORY, - VP8_STATUS_INVALID_PARAM, - VP8_STATUS_BITSTREAM_ERROR, - VP8_STATUS_UNSUPPORTED_FEATURE, - VP8_STATUS_SUSPENDED, - VP8_STATUS_USER_ABORT, - VP8_STATUS_NOT_ENOUGH_DATA, -} VP8StatusCode; - // Return current status of the decoder: VP8StatusCode VP8Status(VP8Decoder* const dec);