Revision control
++ // 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 entry for the decoder
++ //
++ // Author: Skal (pascal.massimino@gmail.com)
++
++ #include <assert.h>
++ #include <stdlib.h>
++ #include <string.h>
++
++ #include "src/dec/alphai_dec.h"
++ #include "src/dec/common_dec.h"
++ #include "src/dec/vp8_dec.h"
++ #include "src/dec/vp8i_dec.h"
++ #include "src/dec/vp8li_dec.h"
++ #include "src/dec/webpi_dec.h"
++ #include "src/dsp/cpu.h"
++ #include "src/dsp/dsp.h"
++ #include "src/utils/bit_reader_inl_utils.h"
++ #include "src/utils/bit_reader_utils.h"
++ #include "src/utils/thread_utils.h"
++ #include "src/utils/utils.h"
++ #include "src/webp/decode.h"
++ #include "src/webp/format_constants.h"
++ #include "src/webp/types.h"
++
++ //------------------------------------------------------------------------------
++
++ int WebPGetDecoderVersion(void) {
++ return (DEC_MAJ_VERSION << 16) | (DEC_MIN_VERSION << 8) | DEC_REV_VERSION;
++ }
++
++ //------------------------------------------------------------------------------
++ // Signature and pointer-to-function for GetCoeffs() variants below.
++
++ typedef int (*GetCoeffsFunc)(VP8BitReader* const br,
++ const VP8BandProbas* const prob[],
++ int ctx, const quant_t dq, int n, int16_t* out);
++ static volatile GetCoeffsFunc GetCoeffs = NULL;
++
++ static void InitGetCoeffs(void);
++
++ //------------------------------------------------------------------------------
++ // VP8Decoder
++
++ static void SetOk(VP8Decoder* const dec) {
++ dec->status = VP8_STATUS_OK;
++ dec->error_msg = "OK";
++ }
++
++ int VP8InitIoInternal(VP8Io* const io, int version) {
++ if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
++ return 0; // mismatch error
++ }
++ if (io != NULL) {
++ memset(io, 0, sizeof(*io));
++ }
++ return 1;
++ }
++
++ VP8Decoder* VP8New(void) {
++ VP8Decoder* const dec = (VP8Decoder*)WebPSafeCalloc(1ULL, sizeof(*dec));
++ if (dec != NULL) {
++ SetOk(dec);
++ WebPGetWorkerInterface()->Init(&dec->worker);
++ dec->ready = 0;
++ dec->num_parts_minus_one = 0;
++ InitGetCoeffs();
++ }
++ return dec;
++ }
++
++ VP8StatusCode VP8Status(VP8Decoder* const dec) {
++ if (!dec) return VP8_STATUS_INVALID_PARAM;
++ return dec->status;
++ }
++
++ const char* VP8StatusMessage(VP8Decoder* const dec) {
++ if (dec == NULL) return "no object";
++ if (!dec->error_msg) return "OK";
++ return dec->error_msg;
++ }
++
++ void VP8Delete(VP8Decoder* const dec) {
++ if (dec != NULL) {
++ VP8Clear(dec);
++ WebPSafeFree(dec);
++ }
++ }
++
++ int VP8SetError(VP8Decoder* const dec,
++ VP8StatusCode error, const char* const msg) {
++ // VP8_STATUS_SUSPENDED is only meaningful in incremental decoding.
++ assert(dec->incremental || error != VP8_STATUS_SUSPENDED);
++ // The oldest error reported takes precedence over the new one.
++ if (dec->status == VP8_STATUS_OK) {
++ dec->status = error;
++ dec->error_msg = msg;
++ dec->ready = 0;
++ }
++ return 0;
++ }
++
++ //------------------------------------------------------------------------------
++
++ int VP8CheckSignature(const uint8_t* const data, size_t data_size) {
++ return (data_size >= 3 &&
++ data[0] == 0x9d && data[1] == 0x01 && data[2] == 0x2a);
++ }
++
++ int VP8GetInfo(const uint8_t* data, size_t data_size, size_t chunk_size,
++ int* const width, int* const height) {
++ if (data == NULL || data_size < VP8_FRAME_HEADER_SIZE) {
++ return 0; // not enough data
++ }
++ // check signature
++ if (!VP8CheckSignature(data + 3, data_size - 3)) {
++ return 0; // Wrong signature.
++ } else {
++ const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
++ const int key_frame = !(bits & 1);
++ const int w = ((data[7] << 8) | data[6]) & 0x3fff;
++ const int h = ((data[9] << 8) | data[8]) & 0x3fff;
++
++ if (!key_frame) { // Not a keyframe.
++ return 0;
++ }
++
++ if (((bits >> 1) & 7) > 3) {
++ return 0; // unknown profile
++ }
++ if (!((bits >> 4) & 1)) {
++ return 0; // first frame is invisible!
++ }
++ if (((bits >> 5)) >= chunk_size) { // partition_length
++ return 0; // inconsistent size information.
++ }
++ if (w == 0 || h == 0) {
++ return 0; // We don't support both width and height to be zero.
++ }
++
++ if (width) {
++ *width = w;
++ }
++ if (height) {
++ *height = h;
++ }
++
++ return 1;
++ }
++ }
++
++ //------------------------------------------------------------------------------
++ // Header parsing
++
++ static void ResetSegmentHeader(VP8SegmentHeader* const hdr) {
++ assert(hdr != NULL);
++ hdr->use_segment = 0;
++ hdr->update_map = 0;
++ hdr->absolute_delta = 1;
++ memset(hdr->quantizer, 0, sizeof(hdr->quantizer));
++ memset(hdr->filter_strength, 0, sizeof(hdr->filter_strength));
++ }
++
++ // Paragraph 9.3
++ static int ParseSegmentHeader(VP8BitReader* br,
++ VP8SegmentHeader* hdr, VP8Proba* proba) {
++ assert(br != NULL);
++ assert(hdr != NULL);
++ hdr->use_segment = VP8Get(br, "global-header");
++ if (hdr->use_segment) {
++ hdr->update_map = VP8Get(br, "global-header");
++ if (VP8Get(br, "global-header")) { // update data
++ int s;
++ hdr->absolute_delta = VP8Get(br, "global-header");
++ for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
++ hdr->quantizer[s] = VP8Get(br, "global-header") ?
++ VP8GetSignedValue(br, 7, "global-header") : 0;
++ }
++ for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
++ hdr->filter_strength[s] = VP8Get(br, "global-header") ?
++ VP8GetSignedValue(br, 6, "global-header") : 0;
++ }
++ }
++ if (hdr->update_map) {
++ int s;
++ for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
++ proba->segments[s] = VP8Get(br, "global-header") ?
++ VP8GetValue(br, 8, "global-header") : 255u;
++ }
++ }
++ } else {
++ hdr->update_map = 0;
++ }
++ return !br->eof;
++ }
++
++ // Paragraph 9.5
++ // If we don't have all the necessary data in 'buf', this function returns
++ // VP8_STATUS_SUSPENDED in incremental decoding, VP8_STATUS_NOT_ENOUGH_DATA
++ // otherwise.
++ // In incremental decoding, this case is not necessarily an error. Still, no
++ // bitreader is ever initialized to make it possible to read unavailable memory.
++ // If we don't even have the partitions' sizes, then VP8_STATUS_NOT_ENOUGH_DATA
++ // is returned, and this is an unrecoverable error.
++ // If the partitions were positioned ok, VP8_STATUS_OK is returned.
++ static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
++ const uint8_t* buf, size_t size) {
++ VP8BitReader* const br = &dec->br;
++ const uint8_t* sz = buf;
++ const uint8_t* buf_end = buf + size;
++ const uint8_t* part_start;
++ size_t size_left = size;
++ size_t last_part;
++ size_t p;
++
++ dec->num_parts_minus_one = (1 << VP8GetValue(br, 2, "global-header")) - 1;
++ last_part = dec->num_parts_minus_one;
++ if (size < 3 * last_part) {
++ // we can't even read the sizes with sz[]! That's a failure.
++ return VP8_STATUS_NOT_ENOUGH_DATA;
++ }
++ part_start = buf + last_part * 3;
++ size_left -= last_part * 3;
++ for (p = 0; p < last_part; ++p) {
++ size_t psize = sz[0] | (sz[1] << 8) | (sz[2] << 16);
++ if (psize > size_left) psize = size_left;
++ VP8InitBitReader(dec->parts + p, part_start, psize);
++ part_start += psize;
++ size_left -= psize;
++ sz += 3;
++ }
++ VP8InitBitReader(dec->parts + last_part, part_start, size_left);
++ if (part_start < buf_end) return VP8_STATUS_OK;
++ return dec->incremental
++ ? VP8_STATUS_SUSPENDED // Init is ok, but there's not enough data
++ : VP8_STATUS_NOT_ENOUGH_DATA;
++ }
++
++ // Paragraph 9.4
++ static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
++ VP8FilterHeader* const hdr = &dec->filter_hdr;
++ hdr->simple = VP8Get(br, "global-header");
++ hdr->level = VP8GetValue(br, 6, "global-header");
++ hdr->sharpness = VP8GetValue(br, 3, "global-header");
++ hdr->use_lf_delta = VP8Get(br, "global-header");
++ if (hdr->use_lf_delta) {
++ if (VP8Get(br, "global-header")) { // update lf-delta?
++ int i;
++ for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
++ if (VP8Get(br, "global-header")) {
++ hdr->ref_lf_delta[i] = VP8GetSignedValue(br, 6, "global-header");
++ }
++ }
++ for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
++ if (VP8Get(br, "global-header")) {
++ hdr->mode_lf_delta[i] = VP8GetSignedValue(br, 6, "global-header");
++ }
++ }
++ }
++ }
++ dec->filter_type = (hdr->level == 0) ? 0 : hdr->simple ? 1 : 2;
++ return !br->eof;
++ }
++
++ // Topmost call
++ int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
++ const uint8_t* buf;
++ size_t buf_size;
++ VP8FrameHeader* frm_hdr;
++ VP8PictureHeader* pic_hdr;
++ VP8BitReader* br;
++ VP8StatusCode status;
++
++ if (dec == NULL) {
++ return 0;
++ }
++ SetOk(dec);
++ if (io == NULL) {
++ return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
++ "null VP8Io passed to VP8GetHeaders()");
++ }
++ buf = io->data;
++ buf_size = io->data_size;
++ if (buf_size < 4) {
++ return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
++ "Truncated header.");
++ }
++
++ // Paragraph 9.1
++ {
++ const uint32_t bits = buf[0] | (buf[1] << 8) | (buf[2] << 16);
++ frm_hdr = &dec->frm_hdr;
++ frm_hdr->key_frame = !(bits & 1);
++ frm_hdr->profile = (bits >> 1) & 7;
++ frm_hdr->show = (bits >> 4) & 1;
++ frm_hdr->partition_length = (bits >> 5);
++ if (frm_hdr->profile > 3) {
++ return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
++ "Incorrect keyframe parameters.");
++ }
++ if (!frm_hdr->show) {
++ return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
++ "Frame not displayable.");
++ }
++ buf += 3;
++ buf_size -= 3;
++ }
++
++ pic_hdr = &dec->pic_hdr;
++ if (frm_hdr->key_frame) {
++ // Paragraph 9.2
++ if (buf_size < 7) {
++ return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
++ "cannot parse picture header");
++ }
++ if (!VP8CheckSignature(buf, buf_size)) {
++ return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
++ "Bad code word");
++ }
++ pic_hdr->width = ((buf[4] << 8) | buf[3]) & 0x3fff;
++ pic_hdr->xscale = buf[4] >> 6; // ratio: 1, 5/4 5/3 or 2
++ pic_hdr->height = ((buf[6] << 8) | buf[5]) & 0x3fff;
++ pic_hdr->yscale = buf[6] >> 6;
++ buf += 7;
++ buf_size -= 7;
++
++ dec->mb_w = (pic_hdr->width + 15) >> 4;
++ dec->mb_h = (pic_hdr->height + 15) >> 4;
++
++ // Setup default output area (can be later modified during io->setup())
++ io->width = pic_hdr->width;
++ io->height = pic_hdr->height;
++ // IMPORTANT! use some sane dimensions in crop* and scaled* fields.
++ // So they can be used interchangeably without always testing for
++ // 'use_cropping'.
++ io->use_cropping = 0;
++ io->crop_top = 0;
++ io->crop_left = 0;
++ io->crop_right = io->width;
++ io->crop_bottom = io->height;
++ io->use_scaling = 0;
++ io->scaled_width = io->width;
++ io->scaled_height = io->height;
++
++ io->mb_w = io->width; // for soundness
++ io->mb_h = io->height; // ditto
++
++ VP8ResetProba(&dec->proba);
++ ResetSegmentHeader(&dec->segment_hdr);
++ }
++
++ // Check if we have all the partition #0 available, and initialize dec->br
++ // to read this partition (and this partition only).
++ if (frm_hdr->partition_length > buf_size) {
++ return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
++ "bad partition length");
++ }
++
++ br = &dec->br;
++ VP8InitBitReader(br, buf, frm_hdr->partition_length);
++ buf += frm_hdr->partition_length;
++ buf_size -= frm_hdr->partition_length;
++
++ if (frm_hdr->key_frame) {
++ pic_hdr->colorspace = VP8Get(br, "global-header");
++ pic_hdr->clamp_type = VP8Get(br, "global-header");
++ }
++ if (!ParseSegmentHeader(br, &dec->segment_hdr, &dec->proba)) {
++ return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
++ "cannot parse segment header");
++ }
++ // Filter specs
++ if (!ParseFilterHeader(br, dec)) {
++ return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
++ "cannot parse filter header");
++ }
++ status = ParsePartitions(dec, buf, buf_size);
++ if (status != VP8_STATUS_OK) {
++ return VP8SetError(dec, status, "cannot parse partitions");
++ }
++
++ // quantizer change
++ VP8ParseQuant(dec);
++
++ // Frame buffer marking
++ if (!frm_hdr->key_frame) {
++ return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
++ "Not a key frame.");
++ }
++
++ VP8Get(br, "global-header"); // ignore the value of 'update_proba'
++
++ VP8ParseProba(br, dec);
++
++ // sanitized state
++ dec->ready = 1;
++ return 1;
++ }
++
++ //------------------------------------------------------------------------------
++ // Residual decoding (Paragraph 13.2 / 13.3)
++
++ static const uint8_t kCat3[] = { 173, 148, 140, 0 };
++ static const uint8_t kCat4[] = { 176, 155, 140, 135, 0 };
++ static const uint8_t kCat5[] = { 180, 157, 141, 134, 130, 0 };
++ static const uint8_t kCat6[] =
++ { 254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0 };
++ static const uint8_t* const kCat3456[] = { kCat3, kCat4, kCat5, kCat6 };
++ static const uint8_t kZigzag[16] = {
++ 0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15
++ };
++
++ // See section 13-2: https://datatracker.ietf.org/doc/html/rfc6386#section-13.2
++ static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
++ int v;
++ if (!VP8GetBit(br, p[3], "coeffs")) {
++ if (!VP8GetBit(br, p[4], "coeffs")) {
++ v = 2;
++ } else {
++ v = 3 + VP8GetBit(br, p[5], "coeffs");
++ }
++ } else {
++ if (!VP8GetBit(br, p[6], "coeffs")) {
++ if (!VP8GetBit(br, p[7], "coeffs")) {
++ v = 5 + VP8GetBit(br, 159, "coeffs");
++ } else {
++ v = 7 + 2 * VP8GetBit(br, 165, "coeffs");
++ v += VP8GetBit(br, 145, "coeffs");
++ }
++ } else {
++ const uint8_t* tab;
++ const int bit1 = VP8GetBit(br, p[8], "coeffs");
++ const int bit0 = VP8GetBit(br, p[9 + bit1], "coeffs");
++ const int cat = 2 * bit1 + bit0;
++ v = 0;
++ for (tab = kCat3456[cat]; *tab; ++tab) {
++ v += v + VP8GetBit(br, *tab, "coeffs");
++ }
++ v += 3 + (8 << cat);
++ }
++ }
++ return v;
++ }
++
++ // Returns the position of the last non-zero coeff plus one
++ static int GetCoeffsFast(VP8BitReader* const br,
++ const VP8BandProbas* const prob[],
++ int ctx, const quant_t dq, int n, int16_t* out) {
++ const uint8_t* p = prob[n]->probas[ctx];
++ for (; n < 16; ++n) {
++ if (!VP8GetBit(br, p[0], "coeffs")) {
++ return n; // previous coeff was last non-zero coeff
++ }
++ while (!VP8GetBit(br, p[1], "coeffs")) { // sequence of zero coeffs
++ p = prob[++n]->probas[0];
++ if (n == 16) return 16;
++ }
++ { // non zero coeff
++ const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas[0];
++ int v;
++ if (!VP8GetBit(br, p[2], "coeffs")) {
++ v = 1;
++ p = p_ctx[1];
++ } else {
++ v = GetLargeValue(br, p);
++ p = p_ctx[2];
++ }
++ out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
++ }
++ }
++ return 16;
++ }
++
++ // This version of GetCoeffs() uses VP8GetBitAlt() which is an alternate version
++ // of VP8GetBitAlt() targeting specific platforms.
++ static int GetCoeffsAlt(VP8BitReader* const br,
++ const VP8BandProbas* const prob[],
++ int ctx, const quant_t dq, int n, int16_t* out) {
++ const uint8_t* p = prob[n]->probas[ctx];
++ for (; n < 16; ++n) {
++ if (!VP8GetBitAlt(br, p[0], "coeffs")) {
++ return n; // previous coeff was last non-zero coeff
++ }
++ while (!VP8GetBitAlt(br, p[1], "coeffs")) { // sequence of zero coeffs
++ p = prob[++n]->probas[0];
++ if (n == 16) return 16;
++ }
++ { // non zero coeff
++ const VP8ProbaArray* const p_ctx = &prob[n + 1]->probas[0];
++ int v;
++ if (!VP8GetBitAlt(br, p[2], "coeffs")) {
++ v = 1;
++ p = p_ctx[1];
++ } else {
++ v = GetLargeValue(br, p);
++ p = p_ctx[2];
++ }
++ out[kZigzag[n]] = VP8GetSigned(br, v, "coeffs") * dq[n > 0];
++ }
++ }
++ return 16;
++ }
++
++ extern VP8CPUInfo VP8GetCPUInfo;
++
++ WEBP_DSP_INIT_FUNC(InitGetCoeffs) {
++ if (VP8GetCPUInfo != NULL && VP8GetCPUInfo(kSlowSSSE3)) {
++ GetCoeffs = GetCoeffsAlt;
++ } else {
++ GetCoeffs = GetCoeffsFast;
++ }
++ }
++
++ static WEBP_INLINE uint32_t NzCodeBits(uint32_t nz_coeffs, int nz, int dc_nz) {
++ nz_coeffs <<= 2;
++ nz_coeffs |= (nz > 3) ? 3 : (nz > 1) ? 2 : dc_nz;
++ return nz_coeffs;
++ }
++
++ static int ParseResiduals(VP8Decoder* const dec,
++ VP8MB* const mb, VP8BitReader* const token_br) {
++ const VP8BandProbas* (* const bands)[16 + 1] = dec->proba.bands_ptr;
++ const VP8BandProbas* const * ac_proba;
++ VP8MBData* const block = dec->mb_data + dec->mb_x;
++ const VP8QuantMatrix* const q = &dec->dqm[block->segment];
++ int16_t* dst = block->coeffs;
++ VP8MB* const left_mb = dec->mb_info - 1;
++ uint8_t tnz, lnz;
++ uint32_t non_zero_y = 0;
++ uint32_t non_zero_uv = 0;
++ int x, y, ch;
++ uint32_t out_t_nz, out_l_nz;
++ int first;
++
++ memset(dst, 0, 384 * sizeof(*dst));
++ if (!block->is_i4x4) { // parse DC
++ int16_t dc[16] = { 0 };
++ const int ctx = mb->nz_dc + left_mb->nz_dc;
++ const int nz = GetCoeffs(token_br, bands[1], ctx, q->y2_mat, 0, dc);
++ mb->nz_dc = left_mb->nz_dc = (nz > 0);
++ if (nz > 1) { // more than just the DC -> perform the full transform
++ VP8TransformWHT(dc, dst);
++ } else { // only DC is non-zero -> inlined simplified transform
++ int i;
++ const int dc0 = (dc[0] + 3) >> 3;
++ for (i = 0; i < 16 * 16; i += 16) dst[i] = dc0;
++ }
++ first = 1;
++ ac_proba = bands[0];
++ } else {
++ first = 0;
++ ac_proba = bands[3];
++ }
++
++ tnz = mb->nz & 0x0f;
++ lnz = left_mb->nz & 0x0f;
++ for (y = 0; y < 4; ++y) {
++ int l = lnz & 1;
++ uint32_t nz_coeffs = 0;
++ for (x = 0; x < 4; ++x) {
++ const int ctx = l + (tnz & 1);
++ const int nz = GetCoeffs(token_br, ac_proba, ctx, q->y1_mat, first, dst);
++ l = (nz > first);
++ tnz = (tnz >> 1) | (l << 7);
++ nz_coeffs = NzCodeBits(nz_coeffs, nz, dst[0] != 0);
++ dst += 16;
++ }
++ tnz >>= 4;
++ lnz = (lnz >> 1) | (l << 7);
++ non_zero_y = (non_zero_y << 8) | nz_coeffs;
++ }
++ out_t_nz = tnz;
++ out_l_nz = lnz >> 4;
++
++ for (ch = 0; ch < 4; ch += 2) {
++ uint32_t nz_coeffs = 0;
++ tnz = mb->nz >> (4 + ch);
++ lnz = left_mb->nz >> (4 + ch);
++ for (y = 0; y < 2; ++y) {
++ int l = lnz & 1;
++ for (x = 0; x < 2; ++x) {
++ const int ctx = l + (tnz & 1);
++ const int nz = GetCoeffs(token_br, bands[2], ctx, q->uv_mat, 0, dst);
++ l = (nz > 0);
++ tnz = (tnz >> 1) | (l << 3);
++ nz_coeffs = NzCodeBits(nz_coeffs, nz, dst[0] != 0);
++ dst += 16;
++ }
++ tnz >>= 2;
++ lnz = (lnz >> 1) | (l << 5);
++ }
++ // Note: we don't really need the per-4x4 details for U/V blocks.
++ non_zero_uv |= nz_coeffs << (4 * ch);
++ out_t_nz |= (tnz << 4) << ch;
++ out_l_nz |= (lnz & 0xf0) << ch;
++ }
++ mb->nz = out_t_nz;
++ left_mb->nz = out_l_nz;
++
++ block->non_zero_y = non_zero_y;
++ block->non_zero_uv = non_zero_uv;
++
++ // We look at the mode-code of each block and check if some blocks have less
++ // than three non-zero coeffs (code < 2). This is to avoid dithering flat and
++ // empty blocks.
++ block->dither = (non_zero_uv & 0xaaaa) ? 0 : q->dither;
++
++ return !(non_zero_y | non_zero_uv); // will be used for further optimization
++ }
++
++ //------------------------------------------------------------------------------
++ // Main loop
++
++ int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) {
++ VP8MB* const left = dec->mb_info - 1;
++ VP8MB* const mb = dec->mb_info + dec->mb_x;
++ VP8MBData* const block = dec->mb_data + dec->mb_x;
++ int skip = dec->use_skip_proba ? block->skip : 0;
++
++ if (!skip) {
++ skip = ParseResiduals(dec, mb, token_br);
++ } else {
++ left->nz = mb->nz = 0;
++ if (!block->is_i4x4) {
++ left->nz_dc = mb->nz_dc = 0;
++ }
++ block->non_zero_y = 0;
++ block->non_zero_uv = 0;
++ block->dither = 0;
++ }
++
++ if (dec->filter_type > 0) { // store filter info
++ VP8FInfo* const finfo = dec->f_info + dec->mb_x;
++ *finfo = dec->fstrengths[block->segment][block->is_i4x4];
++ finfo->f_inner |= !skip;
++ }
++
++ return !token_br->eof;
++ }
++
++ void VP8InitScanline(VP8Decoder* const dec) {
++ VP8MB* const left = dec->mb_info - 1;
++ left->nz = 0;
++ left->nz_dc = 0;
++ memset(dec->intra_l, B_DC_PRED, sizeof(dec->intra_l));
++ dec->mb_x = 0;
++ }
++
++ static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
++ for (dec->mb_y = 0; dec->mb_y < dec->br_mb_y; ++dec->mb_y) {
++ // Parse bitstream for this row.
++ VP8BitReader* const token_br =
++ &dec->parts[dec->mb_y & dec->num_parts_minus_one];
++ if (!VP8ParseIntraModeRow(&dec->br, dec)) {
++ return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
++ "Premature end-of-partition0 encountered.");
++ }
++ for (; dec->mb_x < dec->mb_w; ++dec->mb_x) {
++ if (!VP8DecodeMB(dec, token_br)) {
++ return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
++ "Premature end-of-file encountered.");
++ }
++ }
++ VP8InitScanline(dec); // Prepare for next scanline
++
++ // Reconstruct, filter and emit the row.
++ if (!VP8ProcessRow(dec, io)) {
++ return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
++ }
++ }
++ if (dec->mt_method > 0) {
++ if (!WebPGetWorkerInterface()->Sync(&dec->worker)) return 0;
++ }
++
++ return 1;
++ }
++
++ // Main entry point
++ int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
++ int ok = 0;
++ if (dec == NULL) {
++ return 0;
++ }
++ if (io == NULL) {
++ return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
++ "NULL VP8Io parameter in VP8Decode().");
++ }
++
++ if (!dec->ready) {
++ if (!VP8GetHeaders(dec, io)) {
++ return 0;
++ }
++ }
++ assert(dec->ready);
++
++ // Finish setting up the decoding parameter. Will call io->setup().
++ ok = (VP8EnterCritical(dec, io) == VP8_STATUS_OK);
++ if (ok) { // good to go.
++ // Will allocate memory and prepare everything.
++ if (ok) ok = VP8InitFrame(dec, io);
++
++ // Main decoding loop
++ if (ok) ok = ParseFrame(dec, io);
++
++ // Exit.
++ ok &= VP8ExitCritical(dec, io);
++ }
++
++ if (!ok) {
++ VP8Clear(dec);
++ return 0;
++ }
++
++ dec->ready = 0;
++ return ok;
++ }
++
++ void VP8Clear(VP8Decoder* const dec) {
++ if (dec == NULL) {
++ return;
++ }
++ WebPGetWorkerInterface()->End(&dec->worker);
++ WebPDeallocateAlphaMemory(dec);
++ WebPSafeFree(dec->mem);
++ dec->mem = NULL;
++ dec->mem_size = 0;
++ memset(&dec->br, 0, sizeof(dec->br));
++ dec->ready = 0;
++ }
++
++ //------------------------------------------------------------------------------