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