| // Copyright 2010 Google Inc. All Rights Reserved. |
| // |
| // Use of this source code is governed by a BSD-style license |
| // that can be found in the COPYING file in the root of the source |
| // tree. An additional intellectual property rights grant can be found |
| // in the file PATENTS. All contributing project authors may |
| // be found in the AUTHORS file in the root of the source tree. |
| // ----------------------------------------------------------------------------- |
| // |
| // Main decoding functions for WEBP images. |
| // |
| // Author: Skal (pascal.massimino@gmail.com) |
| |
| #if defined(STARBOARD) |
| #include "starboard/log.h" |
| #include "starboard/memory.h" |
| #else |
| #include <stdlib.h> |
| #endif |
| |
| #include "./vp8i.h" |
| #include "./vp8li.h" |
| #include "./webpi.h" |
| #include "../webp/mux_types.h" // ALPHA_FLAG |
| |
| #if defined(__cplusplus) || defined(c_plusplus) |
| extern "C" { |
| #endif |
| |
| //------------------------------------------------------------------------------ |
| // RIFF layout is: |
| // Offset tag |
| // 0...3 "RIFF" 4-byte tag |
| // 4...7 size of image data (including metadata) starting at offset 8 |
| // 8...11 "WEBP" our form-type signature |
| // The RIFF container (12 bytes) is followed by appropriate chunks: |
| // 12..15 "VP8 ": 4-bytes tags, signaling the use of VP8 video format |
| // 16..19 size of the raw VP8 image data, starting at offset 20 |
| // 20.... the VP8 bytes |
| // Or, |
| // 12..15 "VP8L": 4-bytes tags, signaling the use of VP8L lossless format |
| // 16..19 size of the raw VP8L image data, starting at offset 20 |
| // 20.... the VP8L bytes |
| // Or, |
| // 12..15 "VP8X": 4-bytes tags, describing the extended-VP8 chunk. |
| // 16..19 size of the VP8X chunk starting at offset 20. |
| // 20..23 VP8X flags bit-map corresponding to the chunk-types present. |
| // 24..26 Width of the Canvas Image. |
| // 27..29 Height of the Canvas Image. |
| // There can be extra chunks after the "VP8X" chunk (ICCP, FRGM, ANMF, VP8, |
| // VP8L, XMP, EXIF ...) |
| // All sizes are in little-endian order. |
| // Note: chunk data size must be padded to multiple of 2 when written. |
| |
| static WEBP_INLINE uint32_t get_le24(const uint8_t* const data) { |
| return data[0] | (data[1] << 8) | (data[2] << 16); |
| } |
| |
| static WEBP_INLINE uint32_t get_le32(const uint8_t* const data) { |
| return (uint32_t)get_le24(data) | (data[3] << 24); |
| } |
| |
| // Validates the RIFF container (if detected) and skips over it. |
| // If a RIFF container is detected, |
| // Returns VP8_STATUS_BITSTREAM_ERROR for invalid header, and |
| // VP8_STATUS_OK otherwise. |
| // In case there are not enough bytes (partial RIFF container), return 0 for |
| // *riff_size. Else return the RIFF size extracted from the header. |
| static VP8StatusCode ParseRIFF(const uint8_t** const data, |
| size_t* const data_size, |
| size_t* const riff_size) { |
| SB_DCHECK(data != NULL); |
| SB_DCHECK(data_size != NULL); |
| SB_DCHECK(riff_size != NULL); |
| |
| *riff_size = 0; // Default: no RIFF present. |
| if (*data_size >= RIFF_HEADER_SIZE && !SbMemoryCompare(*data, "RIFF", TAG_SIZE)) { |
| if (SbMemoryCompare(*data + 8, "WEBP", TAG_SIZE)) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Wrong image file signature. |
| } else { |
| const uint32_t size = get_le32(*data + TAG_SIZE); |
| // Check that we have at least one chunk (i.e "WEBP" + "VP8?nnnn"). |
| if (size < TAG_SIZE + CHUNK_HEADER_SIZE) { |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| if (size > MAX_CHUNK_PAYLOAD) { |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| // We have a RIFF container. Skip it. |
| *riff_size = size; |
| *data += RIFF_HEADER_SIZE; |
| *data_size -= RIFF_HEADER_SIZE; |
| } |
| } |
| return VP8_STATUS_OK; |
| } |
| |
| // Validates the VP8X header and skips over it. |
| // Returns VP8_STATUS_BITSTREAM_ERROR for invalid VP8X header, |
| // VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and |
| // VP8_STATUS_OK otherwise. |
| // If a VP8X chunk is found, found_vp8x is set to true and *width_ptr, |
| // *height_ptr and *flags_ptr are set to the corresponding values extracted |
| // from the VP8X chunk. |
| static VP8StatusCode ParseVP8X(const uint8_t** const data, |
| size_t* const data_size, |
| int* const found_vp8x, |
| int* const width_ptr, int* const height_ptr, |
| uint32_t* const flags_ptr) { |
| const uint32_t vp8x_size = CHUNK_HEADER_SIZE + VP8X_CHUNK_SIZE; |
| SB_DCHECK(data != NULL); |
| SB_DCHECK(data_size != NULL); |
| SB_DCHECK(found_vp8x != NULL); |
| |
| *found_vp8x = 0; |
| |
| if (*data_size < CHUNK_HEADER_SIZE) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; // Insufficient data. |
| } |
| |
| if (!SbMemoryCompare(*data, "VP8X", TAG_SIZE)) { |
| int width, height; |
| uint32_t flags; |
| const uint32_t chunk_size = get_le32(*data + TAG_SIZE); |
| if (chunk_size != VP8X_CHUNK_SIZE) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Wrong chunk size. |
| } |
| |
| // Verify if enough data is available to validate the VP8X chunk. |
| if (*data_size < vp8x_size) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; // Insufficient data. |
| } |
| flags = get_le32(*data + 8); |
| width = 1 + get_le24(*data + 12); |
| height = 1 + get_le24(*data + 15); |
| if (width * (uint64_t)height >= MAX_IMAGE_AREA) { |
| return VP8_STATUS_BITSTREAM_ERROR; // image is too large |
| } |
| |
| if (flags_ptr != NULL) *flags_ptr = flags; |
| if (width_ptr != NULL) *width_ptr = width; |
| if (height_ptr != NULL) *height_ptr = height; |
| // Skip over VP8X header bytes. |
| *data += vp8x_size; |
| *data_size -= vp8x_size; |
| *found_vp8x = 1; |
| } |
| return VP8_STATUS_OK; |
| } |
| |
| // Skips to the next VP8/VP8L chunk header in the data given the size of the |
| // RIFF chunk 'riff_size'. |
| // Returns VP8_STATUS_BITSTREAM_ERROR if any invalid chunk size is encountered, |
| // VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and |
| // VP8_STATUS_OK otherwise. |
| // If an alpha chunk is found, *alpha_data and *alpha_size are set |
| // appropriately. |
| static VP8StatusCode ParseOptionalChunks(const uint8_t** const data, |
| size_t* const data_size, |
| size_t const riff_size, |
| const uint8_t** const alpha_data, |
| size_t* const alpha_size) { |
| const uint8_t* buf; |
| size_t buf_size; |
| uint32_t total_size = TAG_SIZE + // "WEBP". |
| CHUNK_HEADER_SIZE + // "VP8Xnnnn". |
| VP8X_CHUNK_SIZE; // data. |
| SB_DCHECK(data != NULL); |
| SB_DCHECK(data_size != NULL); |
| buf = *data; |
| buf_size = *data_size; |
| |
| SB_DCHECK(alpha_data != NULL); |
| SB_DCHECK(alpha_size != NULL); |
| *alpha_data = NULL; |
| *alpha_size = 0; |
| |
| while (1) { |
| uint32_t chunk_size; |
| uint32_t disk_chunk_size; // chunk_size with padding |
| |
| *data = buf; |
| *data_size = buf_size; |
| |
| if (buf_size < CHUNK_HEADER_SIZE) { // Insufficient data. |
| return VP8_STATUS_NOT_ENOUGH_DATA; |
| } |
| |
| chunk_size = get_le32(buf + TAG_SIZE); |
| if (chunk_size > MAX_CHUNK_PAYLOAD) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Not a valid chunk size. |
| } |
| // For odd-sized chunk-payload, there's one byte padding at the end. |
| disk_chunk_size = (CHUNK_HEADER_SIZE + chunk_size + 1) & ~1; |
| total_size += disk_chunk_size; |
| |
| // Check that total bytes skipped so far does not exceed riff_size. |
| if (riff_size > 0 && (total_size > riff_size)) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Not a valid chunk size. |
| } |
| |
| // Start of a (possibly incomplete) VP8/VP8L chunk implies that we have |
| // parsed all the optional chunks. |
| // Note: This check must occur before the check 'buf_size < disk_chunk_size' |
| // below to allow incomplete VP8/VP8L chunks. |
| if (!SbMemoryCompare(buf, "VP8 ", TAG_SIZE) || |
| !SbMemoryCompare(buf, "VP8L", TAG_SIZE)) { |
| return VP8_STATUS_OK; |
| } |
| |
| if (buf_size < disk_chunk_size) { // Insufficient data. |
| return VP8_STATUS_NOT_ENOUGH_DATA; |
| } |
| |
| if (!SbMemoryCompare(buf, "ALPH", TAG_SIZE)) { // A valid ALPH header. |
| *alpha_data = buf + CHUNK_HEADER_SIZE; |
| *alpha_size = chunk_size; |
| } |
| |
| // We have a full and valid chunk; skip it. |
| buf += disk_chunk_size; |
| buf_size -= disk_chunk_size; |
| } |
| } |
| |
| // Validates the VP8/VP8L Header ("VP8 nnnn" or "VP8L nnnn") and skips over it. |
| // Returns VP8_STATUS_BITSTREAM_ERROR for invalid (chunk larger than |
| // riff_size) VP8/VP8L header, |
| // VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and |
| // VP8_STATUS_OK otherwise. |
| // If a VP8/VP8L chunk is found, *chunk_size is set to the total number of bytes |
| // extracted from the VP8/VP8L chunk header. |
| // The flag '*is_lossless' is set to 1 in case of VP8L chunk / raw VP8L data. |
| static VP8StatusCode ParseVP8Header(const uint8_t** const data_ptr, |
| size_t* const data_size, |
| size_t riff_size, |
| size_t* const chunk_size, |
| int* const is_lossless) { |
| const uint8_t* const data = *data_ptr; |
| const int is_vp8 = !SbMemoryCompare(data, "VP8 ", TAG_SIZE); |
| const int is_vp8l = !SbMemoryCompare(data, "VP8L", TAG_SIZE); |
| const uint32_t minimal_size = |
| TAG_SIZE + CHUNK_HEADER_SIZE; // "WEBP" + "VP8 nnnn" OR |
| // "WEBP" + "VP8Lnnnn" |
| SB_DCHECK(data != NULL); |
| SB_DCHECK(data_size != NULL); |
| SB_DCHECK(chunk_size != NULL); |
| SB_DCHECK(is_lossless != NULL); |
| |
| if (*data_size < CHUNK_HEADER_SIZE) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; // Insufficient data. |
| } |
| |
| if (is_vp8 || is_vp8l) { |
| // Bitstream contains VP8/VP8L header. |
| const uint32_t size = get_le32(data + TAG_SIZE); |
| if ((riff_size >= minimal_size) && (size > riff_size - minimal_size)) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Inconsistent size information. |
| } |
| // Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header. |
| *chunk_size = size; |
| *data_ptr += CHUNK_HEADER_SIZE; |
| *data_size -= CHUNK_HEADER_SIZE; |
| *is_lossless = is_vp8l; |
| } else { |
| // Raw VP8/VP8L bitstream (no header). |
| *is_lossless = VP8LCheckSignature(data, *data_size); |
| *chunk_size = *data_size; |
| } |
| |
| return VP8_STATUS_OK; |
| } |
| |
| //------------------------------------------------------------------------------ |
| |
| // Fetch '*width', '*height', '*has_alpha' and fill out 'headers' based on |
| // 'data'. All the output parameters may be NULL. If 'headers' is NULL only the |
| // minimal amount will be read to fetch the remaining parameters. |
| // If 'headers' is non-NULL this function will attempt to locate both alpha |
| // data (with or without a VP8X chunk) and the bitstream chunk (VP8/VP8L). |
| // Note: The following chunk sequences (before the raw VP8/VP8L data) are |
| // considered valid by this function: |
| // RIFF + VP8(L) |
| // RIFF + VP8X + (optional chunks) + VP8(L) |
| // ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose. |
| // VP8(L) <-- Not a valid WebP format: only allowed for internal purpose. |
| static VP8StatusCode ParseHeadersInternal(const uint8_t* data, |
| size_t data_size, |
| int* const width, |
| int* const height, |
| int* const has_alpha, |
| int* const has_animation, |
| WebPHeaderStructure* const headers) { |
| int found_riff = 0; |
| int found_vp8x = 0; |
| VP8StatusCode status; |
| WebPHeaderStructure hdrs; |
| |
| if (data == NULL || data_size < RIFF_HEADER_SIZE) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; |
| } |
| SbMemorySet(&hdrs, 0, sizeof(hdrs)); |
| hdrs.data = data; |
| hdrs.data_size = data_size; |
| |
| // Skip over RIFF header. |
| status = ParseRIFF(&data, &data_size, &hdrs.riff_size); |
| if (status != VP8_STATUS_OK) { |
| return status; // Wrong RIFF header / insufficient data. |
| } |
| found_riff = (hdrs.riff_size > 0); |
| |
| // Skip over VP8X. |
| { |
| uint32_t flags = 0; |
| status = ParseVP8X(&data, &data_size, &found_vp8x, width, height, &flags); |
| if (status != VP8_STATUS_OK) { |
| return status; // Wrong VP8X / insufficient data. |
| } |
| if (!found_riff && found_vp8x) { |
| // Note: This restriction may be removed in the future, if it becomes |
| // necessary to send VP8X chunk to the decoder. |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| if (has_alpha != NULL) *has_alpha = !!(flags & ALPHA_FLAG); |
| if (has_animation != NULL) *has_animation = !!(flags & ANIMATION_FLAG); |
| if (found_vp8x && headers == NULL) { |
| return VP8_STATUS_OK; // Return features from VP8X header. |
| } |
| } |
| |
| if (data_size < TAG_SIZE) return VP8_STATUS_NOT_ENOUGH_DATA; |
| |
| // Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH". |
| if ((found_riff && found_vp8x) || |
| (!found_riff && !found_vp8x && !SbMemoryCompare(data, "ALPH", TAG_SIZE))) { |
| status = ParseOptionalChunks(&data, &data_size, hdrs.riff_size, |
| &hdrs.alpha_data, &hdrs.alpha_data_size); |
| if (status != VP8_STATUS_OK) { |
| return status; // Found an invalid chunk size / insufficient data. |
| } |
| } |
| |
| // Skip over VP8/VP8L header. |
| status = ParseVP8Header(&data, &data_size, hdrs.riff_size, |
| &hdrs.compressed_size, &hdrs.is_lossless); |
| if (status != VP8_STATUS_OK) { |
| return status; // Wrong VP8/VP8L chunk-header / insufficient data. |
| } |
| if (hdrs.compressed_size > MAX_CHUNK_PAYLOAD) { |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| |
| if (!hdrs.is_lossless) { |
| if (data_size < VP8_FRAME_HEADER_SIZE) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; |
| } |
| // Validates raw VP8 data. |
| if (!VP8GetInfo(data, data_size, |
| (uint32_t)hdrs.compressed_size, width, height)) { |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| } else { |
| if (data_size < VP8L_FRAME_HEADER_SIZE) { |
| return VP8_STATUS_NOT_ENOUGH_DATA; |
| } |
| // Validates raw VP8L data. |
| if (!VP8LGetInfo(data, data_size, width, height, has_alpha)) { |
| return VP8_STATUS_BITSTREAM_ERROR; |
| } |
| } |
| |
| if (has_alpha != NULL) { |
| // If the data did not contain a VP8X/VP8L chunk the only definitive way |
| // to set this is by looking for alpha data (from an ALPH chunk). |
| *has_alpha |= (hdrs.alpha_data != NULL); |
| } |
| if (headers != NULL) { |
| *headers = hdrs; |
| headers->offset = data - headers->data; |
| SB_DCHECK((uint64_t)(data - headers->data) < MAX_CHUNK_PAYLOAD); |
| SB_DCHECK(headers->offset == headers->data_size - data_size); |
| } |
| return VP8_STATUS_OK; // Return features from VP8 header. |
| } |
| |
| VP8StatusCode WebPParseHeaders(WebPHeaderStructure* const headers) { |
| VP8StatusCode status; |
| int has_animation = 0; |
| SB_DCHECK(headers != NULL); |
| // fill out headers, ignore width/height/has_alpha. |
| status = ParseHeadersInternal(headers->data, headers->data_size, |
| NULL, NULL, NULL, &has_animation, headers); |
| if (status == VP8_STATUS_OK || status == VP8_STATUS_NOT_ENOUGH_DATA) { |
| // TODO(jzern): full support of animation frames will require API additions. |
| if (has_animation) { |
| status = VP8_STATUS_UNSUPPORTED_FEATURE; |
| } |
| } |
| return status; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // WebPDecParams |
| |
| void WebPResetDecParams(WebPDecParams* const params) { |
| if (params) { |
| SbMemorySet(params, 0, sizeof(*params)); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| // "Into" decoding variants |
| |
| // Main flow |
| static VP8StatusCode DecodeInto(const uint8_t* const data, size_t data_size, |
| WebPDecParams* const params) { |
| VP8StatusCode status; |
| VP8Io io; |
| WebPHeaderStructure headers; |
| |
| headers.data = data; |
| headers.data_size = data_size; |
| status = WebPParseHeaders(&headers); // Process Pre-VP8 chunks. |
| if (status != VP8_STATUS_OK) { |
| return status; |
| } |
| |
| SB_DCHECK(params != NULL); |
| VP8InitIo(&io); |
| io.data = headers.data + headers.offset; |
| io.data_size = headers.data_size - headers.offset; |
| WebPInitCustomIo(params, &io); // Plug the I/O functions. |
| |
| if (!headers.is_lossless) { |
| VP8Decoder* const dec = VP8New(); |
| if (dec == NULL) { |
| return VP8_STATUS_OUT_OF_MEMORY; |
| } |
| #ifdef WEBP_USE_THREAD |
| dec->use_threads_ = params->options && (params->options->use_threads > 0); |
| #else |
| dec->use_threads_ = 0; |
| #endif |
| dec->alpha_data_ = headers.alpha_data; |
| dec->alpha_data_size_ = headers.alpha_data_size; |
| |
| // Decode bitstream header, update io->width/io->height. |
| if (!VP8GetHeaders(dec, &io)) { |
| status = dec->status_; // An error occurred. Grab error status. |
| } else { |
| // Allocate/check output buffers. |
| status = WebPAllocateDecBuffer(io.width, io.height, params->options, |
| params->output); |
| if (status == VP8_STATUS_OK) { // Decode |
| if (!VP8Decode(dec, &io)) { |
| status = dec->status_; |
| } |
| } |
| } |
| VP8Delete(dec); |
| } else { |
| VP8LDecoder* const dec = VP8LNew(); |
| if (dec == NULL) { |
| return VP8_STATUS_OUT_OF_MEMORY; |
| } |
| if (!VP8LDecodeHeader(dec, &io)) { |
| status = dec->status_; // An error occurred. Grab error status. |
| } else { |
| // Allocate/check output buffers. |
| status = WebPAllocateDecBuffer(io.width, io.height, params->options, |
| params->output); |
| if (status == VP8_STATUS_OK) { // Decode |
| if (!VP8LDecodeImage(dec)) { |
| status = dec->status_; |
| } |
| } |
| } |
| VP8LDelete(dec); |
| } |
| |
| if (status != VP8_STATUS_OK) { |
| WebPFreeDecBuffer(params->output); |
| } |
| return status; |
| } |
| |
| // Helpers |
| static uint8_t* DecodeIntoRGBABuffer(WEBP_CSP_MODE colorspace, |
| const uint8_t* const data, |
| size_t data_size, |
| uint8_t* const rgba, |
| int stride, size_t size) { |
| WebPDecParams params; |
| WebPDecBuffer buf; |
| if (rgba == NULL) { |
| return NULL; |
| } |
| WebPInitDecBuffer(&buf); |
| WebPResetDecParams(¶ms); |
| params.output = &buf; |
| buf.colorspace = colorspace; |
| buf.u.RGBA.rgba = rgba; |
| buf.u.RGBA.stride = stride; |
| buf.u.RGBA.size = size; |
| buf.is_external_memory = 1; |
| if (DecodeInto(data, data_size, ¶ms) != VP8_STATUS_OK) { |
| return NULL; |
| } |
| return rgba; |
| } |
| |
| uint8_t* WebPDecodeRGBInto(const uint8_t* data, size_t data_size, |
| uint8_t* output, size_t size, int stride) { |
| return DecodeIntoRGBABuffer(MODE_RGB, data, data_size, output, stride, size); |
| } |
| |
| uint8_t* WebPDecodeRGBAInto(const uint8_t* data, size_t data_size, |
| uint8_t* output, size_t size, int stride) { |
| return DecodeIntoRGBABuffer(MODE_RGBA, data, data_size, output, stride, size); |
| } |
| |
| uint8_t* WebPDecodeARGBInto(const uint8_t* data, size_t data_size, |
| uint8_t* output, size_t size, int stride) { |
| return DecodeIntoRGBABuffer(MODE_ARGB, data, data_size, output, stride, size); |
| } |
| |
| uint8_t* WebPDecodeBGRInto(const uint8_t* data, size_t data_size, |
| uint8_t* output, size_t size, int stride) { |
| return DecodeIntoRGBABuffer(MODE_BGR, data, data_size, output, stride, size); |
| } |
| |
| uint8_t* WebPDecodeBGRAInto(const uint8_t* data, size_t data_size, |
| uint8_t* output, size_t size, int stride) { |
| return DecodeIntoRGBABuffer(MODE_BGRA, data, data_size, output, stride, size); |
| } |
| |
| uint8_t* WebPDecodeYUVInto(const uint8_t* data, size_t data_size, |
| uint8_t* luma, size_t luma_size, int luma_stride, |
| uint8_t* u, size_t u_size, int u_stride, |
| uint8_t* v, size_t v_size, int v_stride) { |
| WebPDecParams params; |
| WebPDecBuffer output; |
| if (luma == NULL) return NULL; |
| WebPInitDecBuffer(&output); |
| WebPResetDecParams(¶ms); |
| params.output = &output; |
| output.colorspace = MODE_YUV; |
| output.u.YUVA.y = luma; |
| output.u.YUVA.y_stride = luma_stride; |
| output.u.YUVA.y_size = luma_size; |
| output.u.YUVA.u = u; |
| output.u.YUVA.u_stride = u_stride; |
| output.u.YUVA.u_size = u_size; |
| output.u.YUVA.v = v; |
| output.u.YUVA.v_stride = v_stride; |
| output.u.YUVA.v_size = v_size; |
| output.is_external_memory = 1; |
| if (DecodeInto(data, data_size, ¶ms) != VP8_STATUS_OK) { |
| return NULL; |
| } |
| return luma; |
| } |
| |
| //------------------------------------------------------------------------------ |
| |
| static uint8_t* Decode(WEBP_CSP_MODE mode, const uint8_t* const data, |
| size_t data_size, int* const width, int* const height, |
| WebPDecBuffer* const keep_info) { |
| WebPDecParams params; |
| WebPDecBuffer output; |
| |
| WebPInitDecBuffer(&output); |
| WebPResetDecParams(¶ms); |
| params.output = &output; |
| output.colorspace = mode; |
| |
| // Retrieve (and report back) the required dimensions from bitstream. |
| if (!WebPGetInfo(data, data_size, &output.width, &output.height)) { |
| return NULL; |
| } |
| if (width != NULL) *width = output.width; |
| if (height != NULL) *height = output.height; |
| |
| // Decode |
| if (DecodeInto(data, data_size, ¶ms) != VP8_STATUS_OK) { |
| return NULL; |
| } |
| if (keep_info != NULL) { // keep track of the side-info |
| WebPCopyDecBuffer(&output, keep_info); |
| } |
| // return decoded samples (don't clear 'output'!) |
| return WebPIsRGBMode(mode) ? output.u.RGBA.rgba : output.u.YUVA.y; |
| } |
| |
| uint8_t* WebPDecodeRGB(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| return Decode(MODE_RGB, data, data_size, width, height, NULL); |
| } |
| |
| uint8_t* WebPDecodeRGBA(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| return Decode(MODE_RGBA, data, data_size, width, height, NULL); |
| } |
| |
| uint8_t* WebPDecodeARGB(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| return Decode(MODE_ARGB, data, data_size, width, height, NULL); |
| } |
| |
| uint8_t* WebPDecodeBGR(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| return Decode(MODE_BGR, data, data_size, width, height, NULL); |
| } |
| |
| uint8_t* WebPDecodeBGRA(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| return Decode(MODE_BGRA, data, data_size, width, height, NULL); |
| } |
| |
| uint8_t* WebPDecodeYUV(const uint8_t* data, size_t data_size, |
| int* width, int* height, uint8_t** u, uint8_t** v, |
| int* stride, int* uv_stride) { |
| WebPDecBuffer output; // only to preserve the side-infos |
| uint8_t* const out = Decode(MODE_YUV, data, data_size, |
| width, height, &output); |
| |
| if (out != NULL) { |
| const WebPYUVABuffer* const buf = &output.u.YUVA; |
| *u = buf->u; |
| *v = buf->v; |
| *stride = buf->y_stride; |
| *uv_stride = buf->u_stride; |
| SB_DCHECK(buf->u_stride == buf->v_stride); |
| } |
| return out; |
| } |
| |
| static void DefaultFeatures(WebPBitstreamFeatures* const features) { |
| SB_DCHECK(features != NULL); |
| SbMemorySet(features, 0, sizeof(*features)); |
| features->bitstream_version = 0; |
| } |
| |
| static VP8StatusCode GetFeatures(const uint8_t* const data, size_t data_size, |
| WebPBitstreamFeatures* const features) { |
| if (features == NULL || data == NULL) { |
| return VP8_STATUS_INVALID_PARAM; |
| } |
| DefaultFeatures(features); |
| |
| // Only parse enough of the data to retrieve the features. |
| return ParseHeadersInternal(data, data_size, |
| &features->width, &features->height, |
| &features->has_alpha, &features->has_animation, |
| NULL); |
| } |
| |
| //------------------------------------------------------------------------------ |
| // WebPGetInfo() |
| |
| int WebPGetInfo(const uint8_t* data, size_t data_size, |
| int* width, int* height) { |
| WebPBitstreamFeatures features; |
| |
| if (GetFeatures(data, data_size, &features) != VP8_STATUS_OK) { |
| return 0; |
| } |
| |
| if (width != NULL) { |
| *width = features.width; |
| } |
| if (height != NULL) { |
| *height = features.height; |
| } |
| |
| return 1; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Advance decoding API |
| |
| int WebPInitDecoderConfigInternal(WebPDecoderConfig* config, |
| int version) { |
| if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) { |
| return 0; // version mismatch |
| } |
| if (config == NULL) { |
| return 0; |
| } |
| SbMemorySet(config, 0, sizeof(*config)); |
| DefaultFeatures(&config->input); |
| WebPInitDecBuffer(&config->output); |
| return 1; |
| } |
| |
| VP8StatusCode WebPGetFeaturesInternal(const uint8_t* data, size_t data_size, |
| WebPBitstreamFeatures* features, |
| int version) { |
| if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) { |
| return VP8_STATUS_INVALID_PARAM; // version mismatch |
| } |
| if (features == NULL) { |
| return VP8_STATUS_INVALID_PARAM; |
| } |
| return GetFeatures(data, data_size, features); |
| } |
| |
| VP8StatusCode WebPDecode(const uint8_t* data, size_t data_size, |
| WebPDecoderConfig* config) { |
| WebPDecParams params; |
| VP8StatusCode status; |
| |
| if (config == NULL) { |
| return VP8_STATUS_INVALID_PARAM; |
| } |
| |
| status = GetFeatures(data, data_size, &config->input); |
| if (status != VP8_STATUS_OK) { |
| if (status == VP8_STATUS_NOT_ENOUGH_DATA) { |
| return VP8_STATUS_BITSTREAM_ERROR; // Not-enough-data treated as error. |
| } |
| return status; |
| } |
| |
| WebPResetDecParams(¶ms); |
| params.output = &config->output; |
| params.options = &config->options; |
| status = DecodeInto(data, data_size, ¶ms); |
| |
| return status; |
| } |
| |
| //------------------------------------------------------------------------------ |
| // Cropping and rescaling. |
| |
| int WebPIoInitFromOptions(const WebPDecoderOptions* const options, |
| VP8Io* const io, WEBP_CSP_MODE src_colorspace) { |
| const int W = io->width; |
| const int H = io->height; |
| int x = 0, y = 0, w = W, h = H; |
| |
| // Cropping |
| io->use_cropping = (options != NULL) && (options->use_cropping > 0); |
| if (io->use_cropping) { |
| w = options->crop_width; |
| h = options->crop_height; |
| x = options->crop_left; |
| y = options->crop_top; |
| if (!WebPIsRGBMode(src_colorspace)) { // only snap for YUV420 or YUV422 |
| x &= ~1; |
| y &= ~1; // TODO(later): only for YUV420, not YUV422. |
| } |
| if (x < 0 || y < 0 || w <= 0 || h <= 0 || x + w > W || y + h > H) { |
| return 0; // out of frame boundary error |
| } |
| } |
| io->crop_left = x; |
| io->crop_top = y; |
| io->crop_right = x + w; |
| io->crop_bottom = y + h; |
| io->mb_w = w; |
| io->mb_h = h; |
| |
| // Scaling |
| io->use_scaling = (options != NULL) && (options->use_scaling > 0); |
| if (io->use_scaling) { |
| if (options->scaled_width <= 0 || options->scaled_height <= 0) { |
| return 0; |
| } |
| io->scaled_width = options->scaled_width; |
| io->scaled_height = options->scaled_height; |
| } |
| |
| // Filter |
| io->bypass_filtering = options && options->bypass_filtering; |
| |
| // Fancy upsampler |
| #ifdef FANCY_UPSAMPLING |
| io->fancy_upsampling = (options == NULL) || (!options->no_fancy_upsampling); |
| #endif |
| |
| if (io->use_scaling) { |
| // disable filter (only for large downscaling ratio). |
| io->bypass_filtering = (io->scaled_width < W * 3 / 4) && |
| (io->scaled_height < H * 3 / 4); |
| io->fancy_upsampling = 0; |
| } |
| return 1; |
| } |
| |
| //------------------------------------------------------------------------------ |
| |
| #if defined(__cplusplus) || defined(c_plusplus) |
| } // extern "C" |
| #endif |