third_party/libwebp/dec/vp8.c

   1 // Copyright 2010 Google Inc. All Rights Reserved.
   2 //
   3 // Use of this source code is governed by a BSD-style license
   4 // that can be found in the COPYING file in the root of the source
   5 // tree. An additional intellectual property rights grant can be found
   6 // in the file PATENTS. All contributing project authors may
   7 // be found in the AUTHORS file in the root of the source tree.
   8 // -----------------------------------------------------------------------------
   9 //
  10 // main entry for the decoder
  11 //
  12 // Author: Skal (pascal.massimino@gmail.com)
  13
  14 #include <stdlib.h>
  15
  16 #include "./vp8i.h"
  17 #include "./vp8li.h"
  18 #include "./webpi.h"
  19 #include "../utils/bit_reader.h"
  20
  21 #if defined(__cplusplus) || defined(c_plusplus)
  22 extern "C" {
  23 #endif
  24
  25 //------------------------------------------------------------------------------
  26
  27 int WebPGetDecoderVersion(void) {
  28   return (DEC_MAJ_VERSION << 16) | (DEC_MIN_VERSION << 8) | DEC_REV_VERSION;
  29 }
  30
  31 //------------------------------------------------------------------------------
  32 // VP8Decoder
  33
  34 static void SetOk(VP8Decoder* const dec) {
  35   dec->status_ = VP8_STATUS_OK;
  36   dec->error_msg_ = "OK";
  37 }
  38
  39 int VP8InitIoInternal(VP8Io* const io, int version) {
  40   if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) {
  41     return 0;  // mismatch error
  42   }
  43   if (io != NULL) {
  44     memset(io, 0, sizeof(*io));
  45   }
  46   return 1;
  47 }
  48
  49 VP8Decoder* VP8New(void) {
  50   VP8Decoder* const dec = (VP8Decoder*)calloc(1, sizeof(*dec));
  51   if (dec != NULL) {
  52     SetOk(dec);
  53     WebPWorkerInit(&dec->worker_);
  54     dec->ready_ = 0;
  55     dec->num_parts_ = 1;
  56   }
  57   return dec;
  58 }
  59
  60 VP8StatusCode VP8Status(VP8Decoder* const dec) {
  61   if (!dec) return VP8_STATUS_INVALID_PARAM;
  62   return dec->status_;
  63 }
  64
  65 const char* VP8StatusMessage(VP8Decoder* const dec) {
  66   if (dec == NULL) return "no object";
  67   if (!dec->error_msg_) return "OK";
  68   return dec->error_msg_;
  69 }
  70
  71 void VP8Delete(VP8Decoder* const dec) {
  72   if (dec != NULL) {
  73     VP8Clear(dec);
  74     free(dec);
  75   }
  76 }
  77
  78 int VP8SetError(VP8Decoder* const dec,
  79                 VP8StatusCode error, const char* const msg) {
  80   // TODO This check would be unnecessary if alpha decompression was separated
  81   // from VP8ProcessRow/FinishRow. This avoids setting 'dec->status_' to
  82   // something other than VP8_STATUS_BITSTREAM_ERROR on alpha decompression
  83   // failure.
  84   if (dec->status_ == VP8_STATUS_OK) {
  85     dec->status_ = error;
  86     dec->error_msg_ = msg;
  87     dec->ready_ = 0;
  88   }
  89   return 0;
  90 }
  91
  92 //------------------------------------------------------------------------------
  93
  94 int VP8CheckSignature(const uint8_t* const data, size_t data_size) {
  95   return (data_size >= 3 &&
  96           data[0] == 0x9d && data[1] == 0x01 && data[2] == 0x2a);
  97 }
  98
  99 int VP8GetInfo(const uint8_t* data, size_t data_size, size_t chunk_size,
 100                int* const width, int* const height) {
 101   if (data == NULL || data_size < VP8_FRAME_HEADER_SIZE) {
 102     return 0;         // not enough data
 103   }
 104   // check signature
 105   if (!VP8CheckSignature(data + 3, data_size - 3)) {
 106     return 0;         // Wrong signature.
 107   } else {
 108     const uint32_t bits = data[0] | (data[1] << 8) | (data[2] << 16);
 109     const int key_frame = !(bits & 1);
 110     const int w = ((data[7] << 8) | data[6]) & 0x3fff;
 111     const int h = ((data[9] << 8) | data[8]) & 0x3fff;
 112
 113     if (!key_frame) {   // Not a keyframe.
 114       return 0;
 115     }
 116
 117     if (((bits >> 1) & 7) > 3) {
 118       return 0;         // unknown profile
 119     }
 120     if (!((bits >> 4) & 1)) {
 121       return 0;         // first frame is invisible!
 122     }
 123     if (((bits >> 5)) >= chunk_size) {  // partition_length
 124       return 0;         // inconsistent size information.
 125     }
 126
 127     if (width) {
 128       *width = w;
 129     }
 130     if (height) {
 131       *height = h;
 132     }
 133
 134     return 1;
 135   }
 136 }
 137
 138 //------------------------------------------------------------------------------
 139 // Header parsing
 140
 141 static void ResetSegmentHeader(VP8SegmentHeader* const hdr) {
 142   assert(hdr != NULL);
 143   hdr->use_segment_ = 0;
 144   hdr->update_map_ = 0;
 145   hdr->absolute_delta_ = 1;
 146   memset(hdr->quantizer_, 0, sizeof(hdr->quantizer_));
 147   memset(hdr->filter_strength_, 0, sizeof(hdr->filter_strength_));
 148 }
 149
 150 // Paragraph 9.3
 151 static int ParseSegmentHeader(VP8BitReader* br,
 152                               VP8SegmentHeader* hdr, VP8Proba* proba) {
 153   assert(br != NULL);
 154   assert(hdr != NULL);
 155   hdr->use_segment_ = VP8Get(br);
 156   if (hdr->use_segment_) {
 157     hdr->update_map_ = VP8Get(br);
 158     if (VP8Get(br)) {   // update data
 159       int s;
 160       hdr->absolute_delta_ = VP8Get(br);
 161       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
 162         hdr->quantizer_[s] = VP8Get(br) ? VP8GetSignedValue(br, 7) : 0;
 163       }
 164       for (s = 0; s < NUM_MB_SEGMENTS; ++s) {
 165         hdr->filter_strength_[s] = VP8Get(br) ? VP8GetSignedValue(br, 6) : 0;
 166       }
 167     }
 168     if (hdr->update_map_) {
 169       int s;
 170       for (s = 0; s < MB_FEATURE_TREE_PROBS; ++s) {
 171         proba->segments_[s] = VP8Get(br) ? VP8GetValue(br, 8) : 255u;
 172       }
 173     }
 174   } else {
 175     hdr->update_map_ = 0;
 176   }
 177   return !br->eof_;
 178 }
 179
 180 // Paragraph 9.5
 181 // This function returns VP8_STATUS_SUSPENDED if we don't have all the
 182 // necessary data in 'buf'.
 183 // This case is not necessarily an error (for incremental decoding).
 184 // Still, no bitreader is ever initialized to make it possible to read
 185 // unavailable memory.
 186 // If we don't even have the partitions' sizes, than VP8_STATUS_NOT_ENOUGH_DATA
 187 // is returned, and this is an unrecoverable error.
 188 // If the partitions were positioned ok, VP8_STATUS_OK is returned.
 189 static VP8StatusCode ParsePartitions(VP8Decoder* const dec,
 190                                      const uint8_t* buf, size_t size) {
 191   VP8BitReader* const br = &dec->br_;
 192   const uint8_t* sz = buf;
 193   const uint8_t* buf_end = buf + size;
 194   const uint8_t* part_start;
 195   int last_part;
 196   int p;
 197
 198   dec->num_parts_ = 1 << VP8GetValue(br, 2);
 199   last_part = dec->num_parts_ - 1;
 200   part_start = buf + last_part * 3;
 201   if (buf_end < part_start) {
 202     // we can't even read the sizes with sz[]! That's a failure.
 203     return VP8_STATUS_NOT_ENOUGH_DATA;
 204   }
 205   for (p = 0; p < last_part; ++p) {
 206     const uint32_t psize = sz[0] | (sz[1] << 8) | (sz[2] << 16);
 207     const uint8_t* part_end = part_start + psize;
 208     if (part_end > buf_end) part_end = buf_end;
 209     VP8InitBitReader(dec->parts_ + p, part_start, part_end);
 210     part_start = part_end;
 211     sz += 3;
 212   }
 213   VP8InitBitReader(dec->parts_ + last_part, part_start, buf_end);
 214   return (part_start < buf_end) ? VP8_STATUS_OK :
 215            VP8_STATUS_SUSPENDED;   // Init is ok, but there's not enough data
 216 }
 217
 218 // Paragraph 9.4
 219 static int ParseFilterHeader(VP8BitReader* br, VP8Decoder* const dec) {
 220   VP8FilterHeader* const hdr = &dec->filter_hdr_;
 221   hdr->simple_    = VP8Get(br);
 222   hdr->level_     = VP8GetValue(br, 6);
 223   hdr->sharpness_ = VP8GetValue(br, 3);
 224   hdr->use_lf_delta_ = VP8Get(br);
 225   if (hdr->use_lf_delta_) {
 226     if (VP8Get(br)) {   // update lf-delta?
 227       int i;
 228       for (i = 0; i < NUM_REF_LF_DELTAS; ++i) {
 229         if (VP8Get(br)) {
 230           hdr->ref_lf_delta_[i] = VP8GetSignedValue(br, 6);
 231         }
 232       }
 233       for (i = 0; i < NUM_MODE_LF_DELTAS; ++i) {
 234         if (VP8Get(br)) {
 235           hdr->mode_lf_delta_[i] = VP8GetSignedValue(br, 6);
 236         }
 237       }
 238     }
 239   }
 240   dec->filter_type_ = (hdr->level_ == 0) ? 0 : hdr->simple_ ? 1 : 2;
 241   return !br->eof_;
 242 }
 243
 244 // Topmost call
 245 int VP8GetHeaders(VP8Decoder* const dec, VP8Io* const io) {
 246   const uint8_t* buf;
 247   size_t buf_size;
 248   VP8FrameHeader* frm_hdr;
 249   VP8PictureHeader* pic_hdr;
 250   VP8BitReader* br;
 251   VP8StatusCode status;
 252   WebPHeaderStructure headers;
 253
 254   if (dec == NULL) {
 255     return 0;
 256   }
 257   SetOk(dec);
 258   if (io == NULL) {
 259     return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
 260                        "null VP8Io passed to VP8GetHeaders()");
 261   }
 262
 263   // Process Pre-VP8 chunks.
 264   headers.data = io->data;
 265   headers.data_size = io->data_size;
 266   status = WebPParseHeaders(&headers);
 267   if (status != VP8_STATUS_OK) {
 268     return VP8SetError(dec, status, "Incorrect/incomplete header.");
 269   }
 270   if (headers.is_lossless) {
 271     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 272                        "Unexpected lossless format encountered.");
 273   }
 274
 275   if (dec->alpha_data_ == NULL) {
 276     assert(dec->alpha_data_size_ == 0);
 277     // We have NOT set alpha data yet. Set it now.
 278     // (This is to ensure that dec->alpha_data_ is NOT reset to NULL if
 279     // WebPParseHeaders() is called more than once, as in incremental decoding
 280     // case.)
 281     dec->alpha_data_ = headers.alpha_data;
 282     dec->alpha_data_size_ = headers.alpha_data_size;
 283   }
 284
 285   // Process the VP8 frame header.
 286   buf = headers.data + headers.offset;
 287   buf_size = headers.data_size - headers.offset;
 288   assert(headers.data_size >= headers.offset);  // WebPParseHeaders' guarantee
 289   if (buf_size < 4) {
 290     return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
 291                        "Truncated header.");
 292   }
 293
 294   // Paragraph 9.1
 295   {
 296     const uint32_t bits = buf[0] | (buf[1] << 8) | (buf[2] << 16);
 297     frm_hdr = &dec->frm_hdr_;
 298     frm_hdr->key_frame_ = !(bits & 1);
 299     frm_hdr->profile_ = (bits >> 1) & 7;
 300     frm_hdr->show_ = (bits >> 4) & 1;
 301     frm_hdr->partition_length_ = (bits >> 5);
 302     if (frm_hdr->profile_ > 3)
 303       return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 304                          "Incorrect keyframe parameters.");
 305     if (!frm_hdr->show_)
 306       return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
 307                          "Frame not displayable.");
 308     buf += 3;
 309     buf_size -= 3;
 310   }
 311
 312   pic_hdr = &dec->pic_hdr_;
 313   if (frm_hdr->key_frame_) {
 314     // Paragraph 9.2
 315     if (buf_size < 7) {
 316       return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
 317                          "cannot parse picture header");
 318     }
 319     if (!VP8CheckSignature(buf, buf_size)) {
 320       return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 321                          "Bad code word");
 322     }
 323     pic_hdr->width_ = ((buf[4] << 8) | buf[3]) & 0x3fff;
 324     pic_hdr->xscale_ = buf[4] >> 6;   // ratio: 1, 5/4 5/3 or 2
 325     pic_hdr->height_ = ((buf[6] << 8) | buf[5]) & 0x3fff;
 326     pic_hdr->yscale_ = buf[6] >> 6;
 327     buf += 7;
 328     buf_size -= 7;
 329
 330     dec->mb_w_ = (pic_hdr->width_ + 15) >> 4;
 331     dec->mb_h_ = (pic_hdr->height_ + 15) >> 4;
 332     // Setup default output area (can be later modified during io->setup())
 333     io->width = pic_hdr->width_;
 334     io->height = pic_hdr->height_;
 335     io->use_scaling  = 0;
 336     io->use_cropping = 0;
 337     io->crop_top  = 0;
 338     io->crop_left = 0;
 339     io->crop_right  = io->width;
 340     io->crop_bottom = io->height;
 341     io->mb_w = io->width;   // sanity check
 342     io->mb_h = io->height;  // ditto
 343
 344     VP8ResetProba(&dec->proba_);
 345     ResetSegmentHeader(&dec->segment_hdr_);
 346     dec->segment_ = 0;    // default for intra
 347   }
 348
 349   // Check if we have all the partition #0 available, and initialize dec->br_
 350   // to read this partition (and this partition only).
 351   if (frm_hdr->partition_length_ > buf_size) {
 352     return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
 353                        "bad partition length");
 354   }
 355
 356   br = &dec->br_;
 357   VP8InitBitReader(br, buf, buf + frm_hdr->partition_length_);
 358   buf += frm_hdr->partition_length_;
 359   buf_size -= frm_hdr->partition_length_;
 360
 361   if (frm_hdr->key_frame_) {
 362     pic_hdr->colorspace_ = VP8Get(br);
 363     pic_hdr->clamp_type_ = VP8Get(br);
 364   }
 365   if (!ParseSegmentHeader(br, &dec->segment_hdr_, &dec->proba_)) {
 366     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 367                        "cannot parse segment header");
 368   }
 369   // Filter specs
 370   if (!ParseFilterHeader(br, dec)) {
 371     return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 372                        "cannot parse filter header");
 373   }
 374   status = ParsePartitions(dec, buf, buf_size);
 375   if (status != VP8_STATUS_OK) {
 376     return VP8SetError(dec, status, "cannot parse partitions");
 377   }
 378
 379   // quantizer change
 380   VP8ParseQuant(dec);
 381
 382   // Frame buffer marking
 383   if (!frm_hdr->key_frame_) {
 384     // Paragraph 9.7
 385 #ifndef ONLY_KEYFRAME_CODE
 386     dec->buffer_flags_ = VP8Get(br) << 0;   // update golden
 387     dec->buffer_flags_ |= VP8Get(br) << 1;  // update alt ref
 388     if (!(dec->buffer_flags_ & 1)) {
 389       dec->buffer_flags_ |= VP8GetValue(br, 2) << 2;
 390     }
 391     if (!(dec->buffer_flags_ & 2)) {
 392       dec->buffer_flags_ |= VP8GetValue(br, 2) << 4;
 393     }
 394     dec->buffer_flags_ |= VP8Get(br) << 6;    // sign bias golden
 395     dec->buffer_flags_ |= VP8Get(br) << 7;    // sign bias alt ref
 396 #else
 397     return VP8SetError(dec, VP8_STATUS_UNSUPPORTED_FEATURE,
 398                        "Not a key frame.");
 399 #endif
 400   } else {
 401     dec->buffer_flags_ = 0x003 | 0x100;
 402   }
 403
 404   // Paragraph 9.8
 405 #ifndef ONLY_KEYFRAME_CODE
 406   dec->update_proba_ = VP8Get(br);
 407   if (!dec->update_proba_) {    // save for later restore
 408     dec->proba_saved_ = dec->proba_;
 409   }
 410   dec->buffer_flags_ &= 1 << 8;
 411   dec->buffer_flags_ |=
 412       (frm_hdr->key_frame_ || VP8Get(br)) << 8;    // refresh last frame
 413 #else
 414   VP8Get(br);   // just ignore the value of update_proba_
 415 #endif
 416
 417   VP8ParseProba(br, dec);
 418
 419 #ifdef WEBP_EXPERIMENTAL_FEATURES
 420   // Extensions
 421   if (dec->pic_hdr_.colorspace_) {
 422     const size_t kTrailerSize = 8;
 423     const uint8_t kTrailerMarker = 0x01;
 424     const uint8_t* ext_buf = buf - kTrailerSize;
 425     size_t size;
 426
 427     if (frm_hdr->partition_length_ < kTrailerSize ||
 428         ext_buf[kTrailerSize - 1] != kTrailerMarker) {
 429       return VP8SetError(dec, VP8_STATUS_BITSTREAM_ERROR,
 430                          "RIFF: Inconsistent extra information.");
 431     }
 432
 433     // Layer
 434     size = (ext_buf[0] << 0) | (ext_buf[1] << 8) | (ext_buf[2] << 16);
 435     dec->layer_data_size_ = size;
 436     dec->layer_data_ = NULL;  // will be set later
 437     dec->layer_colorspace_ = ext_buf[3];
 438   }
 439 #endif
 440
 441   // sanitized state
 442   dec->ready_ = 1;
 443   return 1;
 444 }
 445
 446 //------------------------------------------------------------------------------
 447 // Residual decoding (Paragraph 13.2 / 13.3)
 448
 449 static const int kBands[16 + 1] = {
 450   0, 1, 2, 3, 6, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 7,
 451   0  // extra entry as sentinel
 452 };
 453
 454 static const uint8_t kCat3[] = { 173, 148, 140, 0 };
 455 static const uint8_t kCat4[] = { 176, 155, 140, 135, 0 };
 456 static const uint8_t kCat5[] = { 180, 157, 141, 134, 130, 0 };
 457 static const uint8_t kCat6[] =
 458   { 254, 254, 243, 230, 196, 177, 153, 140, 133, 130, 129, 0 };
 459 static const uint8_t* const kCat3456[] = { kCat3, kCat4, kCat5, kCat6 };
 460 static const uint8_t kZigzag[16] = {
 461   0, 1, 4, 8,  5, 2, 3, 6,  9, 12, 13, 10,  7, 11, 14, 15
 462 };
 463
 464 typedef const uint8_t (*ProbaArray)[NUM_CTX][NUM_PROBAS];  // for const-casting
 465 typedef const uint8_t (*ProbaCtxArray)[NUM_PROBAS];
 466
 467 // See section 13-2: http://tools.ietf.org/html/rfc6386#section-13.2
 468 static int GetLargeValue(VP8BitReader* const br, const uint8_t* const p) {
 469   int v;
 470   if (!VP8GetBit(br, p[3])) {
 471     if (!VP8GetBit(br, p[4])) {
 472       v = 2;
 473     } else {
 474       v = 3 + VP8GetBit(br, p[5]);
 475     }
 476   } else {
 477     if (!VP8GetBit(br, p[6])) {
 478       if (!VP8GetBit(br, p[7])) {
 479         v = 5 + VP8GetBit(br, 159);
 480       } else {
 481         v = 7 + 2 * VP8GetBit(br, 165);
 482         v += VP8GetBit(br, 145);
 483       }
 484     } else {
 485       const uint8_t* tab;
 486       const int bit1 = VP8GetBit(br, p[8]);
 487       const int bit0 = VP8GetBit(br, p[9 + bit1]);
 488       const int cat = 2 * bit1 + bit0;
 489       v = 0;
 490       for (tab = kCat3456[cat]; *tab; ++tab) {
 491         v += v + VP8GetBit(br, *tab);
 492       }
 493       v += 3 + (8 << cat);
 494     }
 495   }
 496   return v;
 497 }
 498
 499 // Returns the position of the last non-zero coeff plus one
 500 // (and 0 if there's no coeff at all)
 501 static int GetCoeffs(VP8BitReader* const br, ProbaArray prob,
 502                      int ctx, const quant_t dq, int n, int16_t* out) {
 503   // n is either 0 or 1 here. kBands[n] is not necessary for extracting '*p'.
 504   const uint8_t* p = prob[n][ctx];
 505   if (!VP8GetBit(br, p[0])) {   // first EOB is more a 'CBP' bit.
 506     return 0;
 507   }
 508   for (; n < 16; ++n) {
 509     const ProbaCtxArray p_ctx = prob[kBands[n + 1]];
 510     if (!VP8GetBit(br, p[1])) {
 511       p = p_ctx[0];
 512     } else {  // non zero coeff
 513       int v;
 514       if (!VP8GetBit(br, p[2])) {
 515         v = 1;
 516         p = p_ctx[1];
 517       } else {
 518         v = GetLargeValue(br, p);
 519         p = p_ctx[2];
 520       }
 521       out[kZigzag[n]] = VP8GetSigned(br, v) * dq[n > 0];
 522       if (n < 15 && !VP8GetBit(br, p[0])) {   // EOB
 523         return n + 1;
 524       }
 525     }
 526   }
 527   return 16;
 528 }
 529
 530 // Alias-safe way of converting 4bytes to 32bits.
 531 typedef union {
 532   uint8_t  i8[4];
 533   uint32_t i32;
 534 } PackedNz;
 535
 536 // Table to unpack four bits into four bytes
 537 static const PackedNz kUnpackTab[16] = {
 538   {{0, 0, 0, 0}},  {{1, 0, 0, 0}},  {{0, 1, 0, 0}},  {{1, 1, 0, 0}},
 539   {{0, 0, 1, 0}},  {{1, 0, 1, 0}},  {{0, 1, 1, 0}},  {{1, 1, 1, 0}},
 540   {{0, 0, 0, 1}},  {{1, 0, 0, 1}},  {{0, 1, 0, 1}},  {{1, 1, 0, 1}},
 541   {{0, 0, 1, 1}},  {{1, 0, 1, 1}},  {{0, 1, 1, 1}},  {{1, 1, 1, 1}} };
 542
 543 // Macro to pack four LSB of four bytes into four bits.
 544 #if defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || \
 545     defined(__BIG_ENDIAN__)
 546 #define PACK_CST 0x08040201U
 547 #else
 548 #define PACK_CST 0x01020408U
 549 #endif
 550 #define PACK(X, S) ((((X).i32 * PACK_CST) & 0xff000000) >> (S))
 551
 552 static void ParseResiduals(VP8Decoder* const dec,
 553                            VP8MB* const mb, VP8BitReader* const token_br) {
 554   int out_t_nz, out_l_nz, first;
 555   ProbaArray ac_prob;
 556   const VP8QuantMatrix* q = &dec->dqm_[dec->segment_];
 557   int16_t* dst = dec->coeffs_;
 558   VP8MB* const left_mb = dec->mb_info_ - 1;
 559   PackedNz nz_ac, nz_dc;
 560   PackedNz tnz, lnz;
 561   uint32_t non_zero_ac = 0;
 562   uint32_t non_zero_dc = 0;
 563   int x, y, ch;
 564
 565   nz_dc.i32 = nz_ac.i32 = 0;
 566   memset(dst, 0, 384 * sizeof(*dst));
 567   if (!dec->is_i4x4_) {    // parse DC
 568     int16_t dc[16] = { 0 };
 569     const int ctx = mb->dc_nz_ + left_mb->dc_nz_;
 570     mb->dc_nz_ = left_mb->dc_nz_ =
 571         (GetCoeffs(token_br, (ProbaArray)dec->proba_.coeffs_[1],
 572                    ctx, q->y2_mat_, 0, dc) > 0);
 573     first = 1;
 574     ac_prob = (ProbaArray)dec->proba_.coeffs_[0];
 575     VP8TransformWHT(dc, dst);
 576   } else {
 577     first = 0;
 578     ac_prob = (ProbaArray)dec->proba_.coeffs_[3];
 579   }
 580
 581   tnz = kUnpackTab[mb->nz_ & 0xf];
 582   lnz = kUnpackTab[left_mb->nz_ & 0xf];
 583   for (y = 0; y < 4; ++y) {
 584     int l = lnz.i8[y];
 585     for (x = 0; x < 4; ++x) {
 586       const int ctx = l + tnz.i8[x];
 587       const int nz = GetCoeffs(token_br, ac_prob, ctx,
 588                                q->y1_mat_, first, dst);
 589       tnz.i8[x] = l = (nz > 0);
 590       nz_dc.i8[x] = (dst[0] != 0);
 591       nz_ac.i8[x] = (nz > 1);
 592       dst += 16;
 593     }
 594     lnz.i8[y] = l;
 595     non_zero_dc |= PACK(nz_dc, 24 - y * 4);
 596     non_zero_ac |= PACK(nz_ac, 24 - y * 4);
 597   }
 598   out_t_nz = PACK(tnz, 24);
 599   out_l_nz = PACK(lnz, 24);
 600
 601   tnz = kUnpackTab[mb->nz_ >> 4];
 602   lnz = kUnpackTab[left_mb->nz_ >> 4];
 603   for (ch = 0; ch < 4; ch += 2) {
 604     for (y = 0; y < 2; ++y) {
 605       int l = lnz.i8[ch + y];
 606       for (x = 0; x < 2; ++x) {
 607         const int ctx = l + tnz.i8[ch + x];
 608         const int nz =
 609             GetCoeffs(token_br, (ProbaArray)dec->proba_.coeffs_[2],
 610                       ctx, q->uv_mat_, 0, dst);
 611         tnz.i8[ch + x] = l = (nz > 0);
 612         nz_dc.i8[y * 2 + x] = (dst[0] != 0);
 613         nz_ac.i8[y * 2 + x] = (nz > 1);
 614         dst += 16;
 615       }
 616       lnz.i8[ch + y] = l;
 617     }
 618     non_zero_dc |= PACK(nz_dc, 8 - ch * 2);
 619     non_zero_ac |= PACK(nz_ac, 8 - ch * 2);
 620   }
 621   out_t_nz |= PACK(tnz, 20);
 622   out_l_nz |= PACK(lnz, 20);
 623   mb->nz_ = out_t_nz;
 624   left_mb->nz_ = out_l_nz;
 625
 626   dec->non_zero_ac_ = non_zero_ac;
 627   dec->non_zero_ = non_zero_ac | non_zero_dc;
 628   mb->skip_ = !dec->non_zero_;
 629 }
 630 #undef PACK
 631
 632 //------------------------------------------------------------------------------
 633 // Main loop
 634
 635 int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) {
 636   VP8BitReader* const br = &dec->br_;
 637   VP8MB* const left = dec->mb_info_ - 1;
 638   VP8MB* const info = dec->mb_info_ + dec->mb_x_;
 639
 640   // Note: we don't save segment map (yet), as we don't expect
 641   // to decode more than 1 keyframe.
 642   if (dec->segment_hdr_.update_map_) {
 643     // Hardcoded tree parsing
 644     dec->segment_ = !VP8GetBit(br, dec->proba_.segments_[0]) ?
 645         VP8GetBit(br, dec->proba_.segments_[1]) :
 646         2 + VP8GetBit(br, dec->proba_.segments_[2]);
 647   }
 648   info->skip_ = dec->use_skip_proba_ ? VP8GetBit(br, dec->skip_p_) : 0;
 649
 650   VP8ParseIntraMode(br, dec);
 651   if (br->eof_) {
 652     return 0;
 653   }
 654
 655   if (!info->skip_) {
 656     ParseResiduals(dec, info, token_br);
 657   } else {
 658     left->nz_ = info->nz_ = 0;
 659     if (!dec->is_i4x4_) {
 660       left->dc_nz_ = info->dc_nz_ = 0;
 661     }
 662     dec->non_zero_ = 0;
 663     dec->non_zero_ac_ = 0;
 664   }
 665
 666   if (dec->filter_type_ > 0) {  // store filter info
 667     VP8FInfo* const finfo = dec->f_info_ + dec->mb_x_;
 668     *finfo = dec->fstrengths_[dec->segment_][dec->is_i4x4_];
 669     finfo->f_inner_ = (!info->skip_ || dec->is_i4x4_);
 670   }
 671
 672   return (!token_br->eof_);
 673 }
 674
 675 void VP8InitScanline(VP8Decoder* const dec) {
 676   VP8MB* const left = dec->mb_info_ - 1;
 677   left->nz_ = 0;
 678   left->dc_nz_ = 0;
 679   memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
 680   dec->filter_row_ =
 681     (dec->filter_type_ > 0) &&
 682     (dec->mb_y_ >= dec->tl_mb_y_) && (dec->mb_y_ <= dec->br_mb_y_);
 683 }
 684
 685 static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
 686   for (dec->mb_y_ = 0; dec->mb_y_ < dec->br_mb_y_; ++dec->mb_y_) {
 687     VP8BitReader* const token_br =
 688         &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)];
 689     VP8InitScanline(dec);
 690     for (dec->mb_x_ = 0; dec->mb_x_ < dec->mb_w_;  dec->mb_x_++) {
 691       if (!VP8DecodeMB(dec, token_br)) {
 692         return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
 693                            "Premature end-of-file encountered.");
 694       }
 695       // Reconstruct and emit samples.
 696       VP8ReconstructBlock(dec);
 697     }
 698     if (!VP8ProcessRow(dec, io)) {
 699       return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
 700     }
 701   }
 702   if (dec->use_threads_ && !WebPWorkerSync(&dec->worker_)) {
 703     return 0;
 704   }
 705
 706   // Finish
 707 #ifndef ONLY_KEYFRAME_CODE
 708   if (!dec->update_proba_) {
 709     dec->proba_ = dec->proba_saved_;
 710   }
 711 #endif
 712
 713 #ifdef WEBP_EXPERIMENTAL_FEATURES
 714   if (dec->layer_data_size_ > 0) {
 715     if (!VP8DecodeLayer(dec)) {
 716       return 0;
 717     }
 718   }
 719 #endif
 720
 721   return 1;
 722 }
 723
 724 // Main entry point
 725 int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
 726   int ok = 0;
 727   if (dec == NULL) {
 728     return 0;
 729   }
 730   if (io == NULL) {
 731     return VP8SetError(dec, VP8_STATUS_INVALID_PARAM,
 732                        "NULL VP8Io parameter in VP8Decode().");
 733   }
 734
 735   if (!dec->ready_) {
 736     if (!VP8GetHeaders(dec, io)) {
 737       return 0;
 738     }
 739   }
 740   assert(dec->ready_);
 741
 742   // Finish setting up the decoding parameter. Will call io->setup().
 743   ok = (VP8EnterCritical(dec, io) == VP8_STATUS_OK);
 744   if (ok) {   // good to go.
 745     // Will allocate memory and prepare everything.
 746     if (ok) ok = VP8InitFrame(dec, io);
 747
 748     // Main decoding loop
 749     if (ok) ok = ParseFrame(dec, io);
 750
 751     // Exit.
 752     ok &= VP8ExitCritical(dec, io);
 753   }
 754
 755   if (!ok) {
 756     VP8Clear(dec);
 757     return 0;
 758   }
 759
 760   dec->ready_ = 0;
 761   return ok;
 762 }
 763
 764 void VP8Clear(VP8Decoder* const dec) {
 765   if (dec == NULL) {
 766     return;
 767   }
 768   if (dec->use_threads_) {
 769     WebPWorkerEnd(&dec->worker_);
 770   }
 771   if (dec->mem_) {
 772     free(dec->mem_);
 773   }
 774   dec->mem_ = NULL;
 775   dec->mem_size_ = 0;
 776   memset(&dec->br_, 0, sizeof(dec->br_));
 777   dec->ready_ = 0;
 778 }
 779
 780 //------------------------------------------------------------------------------
 781
 782 #if defined(__cplusplus) || defined(c_plusplus)
 783 }    // extern "C"
 784 #endif