1 | // Copyright 2012 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 | // Authors: Vikas Arora (vikaas.arora@gmail.com) |
13 | // Jyrki Alakuijala (jyrki@google.com) |
14 | |
15 | #include <stdlib.h> |
16 | |
17 | #include "src/dec/alphai_dec.h" |
18 | #include "src/dec/vp8li_dec.h" |
19 | #include "src/dsp/dsp.h" |
20 | #include "src/dsp/lossless.h" |
21 | #include "src/dsp/lossless_common.h" |
22 | #include "src/dsp/yuv.h" |
23 | #include "src/utils/endian_inl_utils.h" |
24 | #include "src/utils/huffman_utils.h" |
25 | #include "src/utils/utils.h" |
26 | |
27 | #define NUM_ARGB_CACHE_ROWS 16 |
28 | |
29 | static const int kCodeLengthLiterals = 16; |
30 | static const int kCodeLengthRepeatCode = 16; |
31 | static const uint8_t [3] = { 2, 3, 7 }; |
32 | static const uint8_t kCodeLengthRepeatOffsets[3] = { 3, 3, 11 }; |
33 | |
34 | // ----------------------------------------------------------------------------- |
35 | // Five Huffman codes are used at each meta code: |
36 | // 1. green + length prefix codes + color cache codes, |
37 | // 2. alpha, |
38 | // 3. red, |
39 | // 4. blue, and, |
40 | // 5. distance prefix codes. |
41 | typedef enum { |
42 | GREEN = 0, |
43 | RED = 1, |
44 | BLUE = 2, |
45 | ALPHA = 3, |
46 | DIST = 4 |
47 | } HuffIndex; |
48 | |
49 | static const uint16_t kAlphabetSize[HUFFMAN_CODES_PER_META_CODE] = { |
50 | NUM_LITERAL_CODES + NUM_LENGTH_CODES, |
51 | NUM_LITERAL_CODES, NUM_LITERAL_CODES, NUM_LITERAL_CODES, |
52 | NUM_DISTANCE_CODES |
53 | }; |
54 | |
55 | static const uint8_t kLiteralMap[HUFFMAN_CODES_PER_META_CODE] = { |
56 | 0, 1, 1, 1, 0 |
57 | }; |
58 | |
59 | #define NUM_CODE_LENGTH_CODES 19 |
60 | static const uint8_t kCodeLengthCodeOrder[NUM_CODE_LENGTH_CODES] = { |
61 | 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 |
62 | }; |
63 | |
64 | #define CODE_TO_PLANE_CODES 120 |
65 | static const uint8_t kCodeToPlane[CODE_TO_PLANE_CODES] = { |
66 | 0x18, 0x07, 0x17, 0x19, 0x28, 0x06, 0x27, 0x29, 0x16, 0x1a, |
67 | 0x26, 0x2a, 0x38, 0x05, 0x37, 0x39, 0x15, 0x1b, 0x36, 0x3a, |
68 | 0x25, 0x2b, 0x48, 0x04, 0x47, 0x49, 0x14, 0x1c, 0x35, 0x3b, |
69 | 0x46, 0x4a, 0x24, 0x2c, 0x58, 0x45, 0x4b, 0x34, 0x3c, 0x03, |
70 | 0x57, 0x59, 0x13, 0x1d, 0x56, 0x5a, 0x23, 0x2d, 0x44, 0x4c, |
71 | 0x55, 0x5b, 0x33, 0x3d, 0x68, 0x02, 0x67, 0x69, 0x12, 0x1e, |
72 | 0x66, 0x6a, 0x22, 0x2e, 0x54, 0x5c, 0x43, 0x4d, 0x65, 0x6b, |
73 | 0x32, 0x3e, 0x78, 0x01, 0x77, 0x79, 0x53, 0x5d, 0x11, 0x1f, |
74 | 0x64, 0x6c, 0x42, 0x4e, 0x76, 0x7a, 0x21, 0x2f, 0x75, 0x7b, |
75 | 0x31, 0x3f, 0x63, 0x6d, 0x52, 0x5e, 0x00, 0x74, 0x7c, 0x41, |
76 | 0x4f, 0x10, 0x20, 0x62, 0x6e, 0x30, 0x73, 0x7d, 0x51, 0x5f, |
77 | 0x40, 0x72, 0x7e, 0x61, 0x6f, 0x50, 0x71, 0x7f, 0x60, 0x70 |
78 | }; |
79 | |
80 | // Memory needed for lookup tables of one Huffman tree group. Red, blue, alpha |
81 | // and distance alphabets are constant (256 for red, blue and alpha, 40 for |
82 | // distance) and lookup table sizes for them in worst case are 630 and 410 |
83 | // respectively. Size of green alphabet depends on color cache size and is equal |
84 | // to 256 (green component values) + 24 (length prefix values) |
85 | // + color_cache_size (between 0 and 2048). |
86 | // All values computed for 8-bit first level lookup with Mark Adler's tool: |
87 | // http://www.hdfgroup.org/ftp/lib-external/zlib/zlib-1.2.5/examples/enough.c |
88 | #define FIXED_TABLE_SIZE (630 * 3 + 410) |
89 | static const uint16_t kTableSize[12] = { |
90 | FIXED_TABLE_SIZE + 654, |
91 | FIXED_TABLE_SIZE + 656, |
92 | FIXED_TABLE_SIZE + 658, |
93 | FIXED_TABLE_SIZE + 662, |
94 | FIXED_TABLE_SIZE + 670, |
95 | FIXED_TABLE_SIZE + 686, |
96 | FIXED_TABLE_SIZE + 718, |
97 | FIXED_TABLE_SIZE + 782, |
98 | FIXED_TABLE_SIZE + 912, |
99 | FIXED_TABLE_SIZE + 1168, |
100 | FIXED_TABLE_SIZE + 1680, |
101 | FIXED_TABLE_SIZE + 2704 |
102 | }; |
103 | |
104 | static int DecodeImageStream(int xsize, int ysize, |
105 | int is_level0, |
106 | VP8LDecoder* const dec, |
107 | uint32_t** const decoded_data); |
108 | |
109 | //------------------------------------------------------------------------------ |
110 | |
111 | int VP8LCheckSignature(const uint8_t* const data, size_t size) { |
112 | return (size >= VP8L_FRAME_HEADER_SIZE && |
113 | data[0] == VP8L_MAGIC_BYTE && |
114 | (data[4] >> 5) == 0); // version |
115 | } |
116 | |
117 | static int ReadImageInfo(VP8LBitReader* const br, |
118 | int* const width, int* const height, |
119 | int* const has_alpha) { |
120 | if (VP8LReadBits(br, 8) != VP8L_MAGIC_BYTE) return 0; |
121 | *width = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1; |
122 | *height = VP8LReadBits(br, VP8L_IMAGE_SIZE_BITS) + 1; |
123 | *has_alpha = VP8LReadBits(br, 1); |
124 | if (VP8LReadBits(br, VP8L_VERSION_BITS) != 0) return 0; |
125 | return !br->eos_; |
126 | } |
127 | |
128 | int VP8LGetInfo(const uint8_t* data, size_t data_size, |
129 | int* const width, int* const height, int* const has_alpha) { |
130 | if (data == NULL || data_size < VP8L_FRAME_HEADER_SIZE) { |
131 | return 0; // not enough data |
132 | } else if (!VP8LCheckSignature(data, data_size)) { |
133 | return 0; // bad signature |
134 | } else { |
135 | int w, h, a; |
136 | VP8LBitReader br; |
137 | VP8LInitBitReader(&br, data, data_size); |
138 | if (!ReadImageInfo(&br, &w, &h, &a)) { |
139 | return 0; |
140 | } |
141 | if (width != NULL) *width = w; |
142 | if (height != NULL) *height = h; |
143 | if (has_alpha != NULL) *has_alpha = a; |
144 | return 1; |
145 | } |
146 | } |
147 | |
148 | //------------------------------------------------------------------------------ |
149 | |
150 | static WEBP_INLINE int GetCopyDistance(int distance_symbol, |
151 | VP8LBitReader* const br) { |
152 | int , offset; |
153 | if (distance_symbol < 4) { |
154 | return distance_symbol + 1; |
155 | } |
156 | extra_bits = (distance_symbol - 2) >> 1; |
157 | offset = (2 + (distance_symbol & 1)) << extra_bits; |
158 | return offset + VP8LReadBits(br, extra_bits) + 1; |
159 | } |
160 | |
161 | static WEBP_INLINE int GetCopyLength(int length_symbol, |
162 | VP8LBitReader* const br) { |
163 | // Length and distance prefixes are encoded the same way. |
164 | return GetCopyDistance(length_symbol, br); |
165 | } |
166 | |
167 | static WEBP_INLINE int PlaneCodeToDistance(int xsize, int plane_code) { |
168 | if (plane_code > CODE_TO_PLANE_CODES) { |
169 | return plane_code - CODE_TO_PLANE_CODES; |
170 | } else { |
171 | const int dist_code = kCodeToPlane[plane_code - 1]; |
172 | const int yoffset = dist_code >> 4; |
173 | const int xoffset = 8 - (dist_code & 0xf); |
174 | const int dist = yoffset * xsize + xoffset; |
175 | return (dist >= 1) ? dist : 1; // dist<1 can happen if xsize is very small |
176 | } |
177 | } |
178 | |
179 | //------------------------------------------------------------------------------ |
180 | // Decodes the next Huffman code from bit-stream. |
181 | // FillBitWindow(br) needs to be called at minimum every second call |
182 | // to ReadSymbol, in order to pre-fetch enough bits. |
183 | static WEBP_INLINE int ReadSymbol(const HuffmanCode* table, |
184 | VP8LBitReader* const br) { |
185 | int nbits; |
186 | uint32_t val = VP8LPrefetchBits(br); |
187 | table += val & HUFFMAN_TABLE_MASK; |
188 | nbits = table->bits - HUFFMAN_TABLE_BITS; |
189 | if (nbits > 0) { |
190 | VP8LSetBitPos(br, br->bit_pos_ + HUFFMAN_TABLE_BITS); |
191 | val = VP8LPrefetchBits(br); |
192 | table += table->value; |
193 | table += val & ((1 << nbits) - 1); |
194 | } |
195 | VP8LSetBitPos(br, br->bit_pos_ + table->bits); |
196 | return table->value; |
197 | } |
198 | |
199 | // Reads packed symbol depending on GREEN channel |
200 | #define BITS_SPECIAL_MARKER 0x100 // something large enough (and a bit-mask) |
201 | #define PACKED_NON_LITERAL_CODE 0 // must be < NUM_LITERAL_CODES |
202 | static WEBP_INLINE int ReadPackedSymbols(const HTreeGroup* group, |
203 | VP8LBitReader* const br, |
204 | uint32_t* const dst) { |
205 | const uint32_t val = VP8LPrefetchBits(br) & (HUFFMAN_PACKED_TABLE_SIZE - 1); |
206 | const HuffmanCode32 code = group->packed_table[val]; |
207 | assert(group->use_packed_table); |
208 | if (code.bits < BITS_SPECIAL_MARKER) { |
209 | VP8LSetBitPos(br, br->bit_pos_ + code.bits); |
210 | *dst = code.value; |
211 | return PACKED_NON_LITERAL_CODE; |
212 | } else { |
213 | VP8LSetBitPos(br, br->bit_pos_ + code.bits - BITS_SPECIAL_MARKER); |
214 | assert(code.value >= NUM_LITERAL_CODES); |
215 | return code.value; |
216 | } |
217 | } |
218 | |
219 | static int AccumulateHCode(HuffmanCode hcode, int shift, |
220 | HuffmanCode32* const huff) { |
221 | huff->bits += hcode.bits; |
222 | huff->value |= (uint32_t)hcode.value << shift; |
223 | assert(huff->bits <= HUFFMAN_TABLE_BITS); |
224 | return hcode.bits; |
225 | } |
226 | |
227 | static void BuildPackedTable(HTreeGroup* const htree_group) { |
228 | uint32_t code; |
229 | for (code = 0; code < HUFFMAN_PACKED_TABLE_SIZE; ++code) { |
230 | uint32_t bits = code; |
231 | HuffmanCode32* const huff = &htree_group->packed_table[bits]; |
232 | HuffmanCode hcode = htree_group->htrees[GREEN][bits]; |
233 | if (hcode.value >= NUM_LITERAL_CODES) { |
234 | huff->bits = hcode.bits + BITS_SPECIAL_MARKER; |
235 | huff->value = hcode.value; |
236 | } else { |
237 | huff->bits = 0; |
238 | huff->value = 0; |
239 | bits >>= AccumulateHCode(hcode, 8, huff); |
240 | bits >>= AccumulateHCode(htree_group->htrees[RED][bits], 16, huff); |
241 | bits >>= AccumulateHCode(htree_group->htrees[BLUE][bits], 0, huff); |
242 | bits >>= AccumulateHCode(htree_group->htrees[ALPHA][bits], 24, huff); |
243 | (void)bits; |
244 | } |
245 | } |
246 | } |
247 | |
248 | static int ReadHuffmanCodeLengths( |
249 | VP8LDecoder* const dec, const int* const code_length_code_lengths, |
250 | int num_symbols, int* const code_lengths) { |
251 | int ok = 0; |
252 | VP8LBitReader* const br = &dec->br_; |
253 | int symbol; |
254 | int max_symbol; |
255 | int prev_code_len = DEFAULT_CODE_LENGTH; |
256 | HuffmanCode table[1 << LENGTHS_TABLE_BITS]; |
257 | |
258 | if (!VP8LBuildHuffmanTable(table, LENGTHS_TABLE_BITS, |
259 | code_length_code_lengths, |
260 | NUM_CODE_LENGTH_CODES)) { |
261 | goto End; |
262 | } |
263 | |
264 | if (VP8LReadBits(br, 1)) { // use length |
265 | const int length_nbits = 2 + 2 * VP8LReadBits(br, 3); |
266 | max_symbol = 2 + VP8LReadBits(br, length_nbits); |
267 | if (max_symbol > num_symbols) { |
268 | goto End; |
269 | } |
270 | } else { |
271 | max_symbol = num_symbols; |
272 | } |
273 | |
274 | symbol = 0; |
275 | while (symbol < num_symbols) { |
276 | const HuffmanCode* p; |
277 | int code_len; |
278 | if (max_symbol-- == 0) break; |
279 | VP8LFillBitWindow(br); |
280 | p = &table[VP8LPrefetchBits(br) & LENGTHS_TABLE_MASK]; |
281 | VP8LSetBitPos(br, br->bit_pos_ + p->bits); |
282 | code_len = p->value; |
283 | if (code_len < kCodeLengthLiterals) { |
284 | code_lengths[symbol++] = code_len; |
285 | if (code_len != 0) prev_code_len = code_len; |
286 | } else { |
287 | const int use_prev = (code_len == kCodeLengthRepeatCode); |
288 | const int slot = code_len - kCodeLengthLiterals; |
289 | const int = kCodeLengthExtraBits[slot]; |
290 | const int repeat_offset = kCodeLengthRepeatOffsets[slot]; |
291 | int repeat = VP8LReadBits(br, extra_bits) + repeat_offset; |
292 | if (symbol + repeat > num_symbols) { |
293 | goto End; |
294 | } else { |
295 | const int length = use_prev ? prev_code_len : 0; |
296 | while (repeat-- > 0) code_lengths[symbol++] = length; |
297 | } |
298 | } |
299 | } |
300 | ok = 1; |
301 | |
302 | End: |
303 | if (!ok) dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
304 | return ok; |
305 | } |
306 | |
307 | // 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman |
308 | // tree. |
309 | static int ReadHuffmanCode(int alphabet_size, VP8LDecoder* const dec, |
310 | int* const code_lengths, HuffmanCode* const table) { |
311 | int ok = 0; |
312 | int size = 0; |
313 | VP8LBitReader* const br = &dec->br_; |
314 | const int simple_code = VP8LReadBits(br, 1); |
315 | |
316 | memset(code_lengths, 0, alphabet_size * sizeof(*code_lengths)); |
317 | |
318 | if (simple_code) { // Read symbols, codes & code lengths directly. |
319 | const int num_symbols = VP8LReadBits(br, 1) + 1; |
320 | const int first_symbol_len_code = VP8LReadBits(br, 1); |
321 | // The first code is either 1 bit or 8 bit code. |
322 | int symbol = VP8LReadBits(br, (first_symbol_len_code == 0) ? 1 : 8); |
323 | code_lengths[symbol] = 1; |
324 | // The second code (if present), is always 8 bit long. |
325 | if (num_symbols == 2) { |
326 | symbol = VP8LReadBits(br, 8); |
327 | code_lengths[symbol] = 1; |
328 | } |
329 | ok = 1; |
330 | } else { // Decode Huffman-coded code lengths. |
331 | int i; |
332 | int code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 }; |
333 | const int num_codes = VP8LReadBits(br, 4) + 4; |
334 | if (num_codes > NUM_CODE_LENGTH_CODES) { |
335 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
336 | return 0; |
337 | } |
338 | |
339 | for (i = 0; i < num_codes; ++i) { |
340 | code_length_code_lengths[kCodeLengthCodeOrder[i]] = VP8LReadBits(br, 3); |
341 | } |
342 | ok = ReadHuffmanCodeLengths(dec, code_length_code_lengths, alphabet_size, |
343 | code_lengths); |
344 | } |
345 | |
346 | ok = ok && !br->eos_; |
347 | if (ok) { |
348 | size = VP8LBuildHuffmanTable(table, HUFFMAN_TABLE_BITS, |
349 | code_lengths, alphabet_size); |
350 | } |
351 | if (!ok || size == 0) { |
352 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
353 | return 0; |
354 | } |
355 | return size; |
356 | } |
357 | |
358 | static int ReadHuffmanCodes(VP8LDecoder* const dec, int xsize, int ysize, |
359 | int color_cache_bits, int allow_recursion) { |
360 | int i, j; |
361 | VP8LBitReader* const br = &dec->br_; |
362 | VP8LMetadata* const hdr = &dec->hdr_; |
363 | uint32_t* huffman_image = NULL; |
364 | HTreeGroup* htree_groups = NULL; |
365 | HuffmanCode* huffman_tables = NULL; |
366 | HuffmanCode* huffman_table = NULL; |
367 | int num_htree_groups = 1; |
368 | int num_htree_groups_max = 1; |
369 | int max_alphabet_size = 0; |
370 | int* code_lengths = NULL; |
371 | const int table_size = kTableSize[color_cache_bits]; |
372 | int* mapping = NULL; |
373 | int ok = 0; |
374 | |
375 | if (allow_recursion && VP8LReadBits(br, 1)) { |
376 | // use meta Huffman codes. |
377 | const int huffman_precision = VP8LReadBits(br, 3) + 2; |
378 | const int huffman_xsize = VP8LSubSampleSize(xsize, huffman_precision); |
379 | const int huffman_ysize = VP8LSubSampleSize(ysize, huffman_precision); |
380 | const int huffman_pixs = huffman_xsize * huffman_ysize; |
381 | if (!DecodeImageStream(huffman_xsize, huffman_ysize, 0, dec, |
382 | &huffman_image)) { |
383 | goto Error; |
384 | } |
385 | hdr->huffman_subsample_bits_ = huffman_precision; |
386 | for (i = 0; i < huffman_pixs; ++i) { |
387 | // The huffman data is stored in red and green bytes. |
388 | const int group = (huffman_image[i] >> 8) & 0xffff; |
389 | huffman_image[i] = group; |
390 | if (group >= num_htree_groups_max) { |
391 | num_htree_groups_max = group + 1; |
392 | } |
393 | } |
394 | // Check the validity of num_htree_groups_max. If it seems too big, use a |
395 | // smaller value for later. This will prevent big memory allocations to end |
396 | // up with a bad bitstream anyway. |
397 | // The value of 1000 is totally arbitrary. We know that num_htree_groups_max |
398 | // is smaller than (1 << 16) and should be smaller than the number of pixels |
399 | // (though the format allows it to be bigger). |
400 | if (num_htree_groups_max > 1000 || num_htree_groups_max > xsize * ysize) { |
401 | // Create a mapping from the used indices to the minimal set of used |
402 | // values [0, num_htree_groups) |
403 | mapping = (int*)WebPSafeMalloc(num_htree_groups_max, sizeof(*mapping)); |
404 | if (mapping == NULL) { |
405 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
406 | goto Error; |
407 | } |
408 | // -1 means a value is unmapped, and therefore unused in the Huffman |
409 | // image. |
410 | memset(mapping, 0xff, num_htree_groups_max * sizeof(*mapping)); |
411 | for (num_htree_groups = 0, i = 0; i < huffman_pixs; ++i) { |
412 | // Get the current mapping for the group and remap the Huffman image. |
413 | int* const mapped_group = &mapping[huffman_image[i]]; |
414 | if (*mapped_group == -1) *mapped_group = num_htree_groups++; |
415 | huffman_image[i] = *mapped_group; |
416 | } |
417 | } else { |
418 | num_htree_groups = num_htree_groups_max; |
419 | } |
420 | } |
421 | |
422 | if (br->eos_) goto Error; |
423 | |
424 | // Find maximum alphabet size for the htree group. |
425 | for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { |
426 | int alphabet_size = kAlphabetSize[j]; |
427 | if (j == 0 && color_cache_bits > 0) { |
428 | alphabet_size += 1 << color_cache_bits; |
429 | } |
430 | if (max_alphabet_size < alphabet_size) { |
431 | max_alphabet_size = alphabet_size; |
432 | } |
433 | } |
434 | |
435 | code_lengths = (int*)WebPSafeCalloc((uint64_t)max_alphabet_size, |
436 | sizeof(*code_lengths)); |
437 | huffman_tables = (HuffmanCode*)WebPSafeMalloc(num_htree_groups * table_size, |
438 | sizeof(*huffman_tables)); |
439 | htree_groups = VP8LHtreeGroupsNew(num_htree_groups); |
440 | |
441 | if (htree_groups == NULL || code_lengths == NULL || huffman_tables == NULL) { |
442 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
443 | goto Error; |
444 | } |
445 | |
446 | huffman_table = huffman_tables; |
447 | for (i = 0; i < num_htree_groups_max; ++i) { |
448 | // If the index "i" is unused in the Huffman image, just make sure the |
449 | // coefficients are valid but do not store them. |
450 | if (mapping != NULL && mapping[i] == -1) { |
451 | for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { |
452 | int alphabet_size = kAlphabetSize[j]; |
453 | if (j == 0 && color_cache_bits > 0) { |
454 | alphabet_size += (1 << color_cache_bits); |
455 | } |
456 | // Passing in NULL so that nothing gets filled. |
457 | if (!ReadHuffmanCode(alphabet_size, dec, code_lengths, NULL)) { |
458 | goto Error; |
459 | } |
460 | } |
461 | } else { |
462 | HTreeGroup* const htree_group = |
463 | &htree_groups[(mapping == NULL) ? i : mapping[i]]; |
464 | HuffmanCode** const htrees = htree_group->htrees; |
465 | int size; |
466 | int total_size = 0; |
467 | int is_trivial_literal = 1; |
468 | int max_bits = 0; |
469 | for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; ++j) { |
470 | int alphabet_size = kAlphabetSize[j]; |
471 | htrees[j] = huffman_table; |
472 | if (j == 0 && color_cache_bits > 0) { |
473 | alphabet_size += (1 << color_cache_bits); |
474 | } |
475 | size = ReadHuffmanCode(alphabet_size, dec, code_lengths, huffman_table); |
476 | if (size == 0) { |
477 | goto Error; |
478 | } |
479 | if (is_trivial_literal && kLiteralMap[j] == 1) { |
480 | is_trivial_literal = (huffman_table->bits == 0); |
481 | } |
482 | total_size += huffman_table->bits; |
483 | huffman_table += size; |
484 | if (j <= ALPHA) { |
485 | int local_max_bits = code_lengths[0]; |
486 | int k; |
487 | for (k = 1; k < alphabet_size; ++k) { |
488 | if (code_lengths[k] > local_max_bits) { |
489 | local_max_bits = code_lengths[k]; |
490 | } |
491 | } |
492 | max_bits += local_max_bits; |
493 | } |
494 | } |
495 | htree_group->is_trivial_literal = is_trivial_literal; |
496 | htree_group->is_trivial_code = 0; |
497 | if (is_trivial_literal) { |
498 | const int red = htrees[RED][0].value; |
499 | const int blue = htrees[BLUE][0].value; |
500 | const int alpha = htrees[ALPHA][0].value; |
501 | htree_group->literal_arb = ((uint32_t)alpha << 24) | (red << 16) | blue; |
502 | if (total_size == 0 && htrees[GREEN][0].value < NUM_LITERAL_CODES) { |
503 | htree_group->is_trivial_code = 1; |
504 | htree_group->literal_arb |= htrees[GREEN][0].value << 8; |
505 | } |
506 | } |
507 | htree_group->use_packed_table = |
508 | !htree_group->is_trivial_code && (max_bits < HUFFMAN_PACKED_BITS); |
509 | if (htree_group->use_packed_table) BuildPackedTable(htree_group); |
510 | } |
511 | } |
512 | ok = 1; |
513 | |
514 | // All OK. Finalize pointers. |
515 | hdr->huffman_image_ = huffman_image; |
516 | hdr->num_htree_groups_ = num_htree_groups; |
517 | hdr->htree_groups_ = htree_groups; |
518 | hdr->huffman_tables_ = huffman_tables; |
519 | |
520 | Error: |
521 | WebPSafeFree(code_lengths); |
522 | WebPSafeFree(mapping); |
523 | if (!ok) { |
524 | WebPSafeFree(huffman_image); |
525 | WebPSafeFree(huffman_tables); |
526 | VP8LHtreeGroupsFree(htree_groups); |
527 | } |
528 | return ok; |
529 | } |
530 | |
531 | //------------------------------------------------------------------------------ |
532 | // Scaling. |
533 | |
534 | #if !defined(WEBP_REDUCE_SIZE) |
535 | static int AllocateAndInitRescaler(VP8LDecoder* const dec, VP8Io* const io) { |
536 | const int num_channels = 4; |
537 | const int in_width = io->mb_w; |
538 | const int out_width = io->scaled_width; |
539 | const int in_height = io->mb_h; |
540 | const int out_height = io->scaled_height; |
541 | const uint64_t work_size = 2 * num_channels * (uint64_t)out_width; |
542 | rescaler_t* work; // Rescaler work area. |
543 | const uint64_t scaled_data_size = (uint64_t)out_width; |
544 | uint32_t* scaled_data; // Temporary storage for scaled BGRA data. |
545 | const uint64_t memory_size = sizeof(*dec->rescaler) + |
546 | work_size * sizeof(*work) + |
547 | scaled_data_size * sizeof(*scaled_data); |
548 | uint8_t* memory = (uint8_t*)WebPSafeMalloc(memory_size, sizeof(*memory)); |
549 | if (memory == NULL) { |
550 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
551 | return 0; |
552 | } |
553 | assert(dec->rescaler_memory == NULL); |
554 | dec->rescaler_memory = memory; |
555 | |
556 | dec->rescaler = (WebPRescaler*)memory; |
557 | memory += sizeof(*dec->rescaler); |
558 | work = (rescaler_t*)memory; |
559 | memory += work_size * sizeof(*work); |
560 | scaled_data = (uint32_t*)memory; |
561 | |
562 | WebPRescalerInit(dec->rescaler, in_width, in_height, (uint8_t*)scaled_data, |
563 | out_width, out_height, 0, num_channels, work); |
564 | return 1; |
565 | } |
566 | #endif // WEBP_REDUCE_SIZE |
567 | |
568 | //------------------------------------------------------------------------------ |
569 | // Export to ARGB |
570 | |
571 | #if !defined(WEBP_REDUCE_SIZE) |
572 | |
573 | // We have special "export" function since we need to convert from BGRA |
574 | static int Export(WebPRescaler* const rescaler, WEBP_CSP_MODE colorspace, |
575 | int rgba_stride, uint8_t* const rgba) { |
576 | uint32_t* const src = (uint32_t*)rescaler->dst; |
577 | const int dst_width = rescaler->dst_width; |
578 | int num_lines_out = 0; |
579 | while (WebPRescalerHasPendingOutput(rescaler)) { |
580 | uint8_t* const dst = rgba + num_lines_out * rgba_stride; |
581 | WebPRescalerExportRow(rescaler); |
582 | WebPMultARGBRow(src, dst_width, 1); |
583 | VP8LConvertFromBGRA(src, dst_width, colorspace, dst); |
584 | ++num_lines_out; |
585 | } |
586 | return num_lines_out; |
587 | } |
588 | |
589 | // Emit scaled rows. |
590 | static int EmitRescaledRowsRGBA(const VP8LDecoder* const dec, |
591 | uint8_t* in, int in_stride, int mb_h, |
592 | uint8_t* const out, int out_stride) { |
593 | const WEBP_CSP_MODE colorspace = dec->output_->colorspace; |
594 | int num_lines_in = 0; |
595 | int num_lines_out = 0; |
596 | while (num_lines_in < mb_h) { |
597 | uint8_t* const row_in = in + num_lines_in * in_stride; |
598 | uint8_t* const row_out = out + num_lines_out * out_stride; |
599 | const int lines_left = mb_h - num_lines_in; |
600 | const int needed_lines = WebPRescaleNeededLines(dec->rescaler, lines_left); |
601 | int lines_imported; |
602 | assert(needed_lines > 0 && needed_lines <= lines_left); |
603 | WebPMultARGBRows(row_in, in_stride, |
604 | dec->rescaler->src_width, needed_lines, 0); |
605 | lines_imported = |
606 | WebPRescalerImport(dec->rescaler, lines_left, row_in, in_stride); |
607 | assert(lines_imported == needed_lines); |
608 | num_lines_in += lines_imported; |
609 | num_lines_out += Export(dec->rescaler, colorspace, out_stride, row_out); |
610 | } |
611 | return num_lines_out; |
612 | } |
613 | |
614 | #endif // WEBP_REDUCE_SIZE |
615 | |
616 | // Emit rows without any scaling. |
617 | static int EmitRows(WEBP_CSP_MODE colorspace, |
618 | const uint8_t* row_in, int in_stride, |
619 | int mb_w, int mb_h, |
620 | uint8_t* const out, int out_stride) { |
621 | int lines = mb_h; |
622 | uint8_t* row_out = out; |
623 | while (lines-- > 0) { |
624 | VP8LConvertFromBGRA((const uint32_t*)row_in, mb_w, colorspace, row_out); |
625 | row_in += in_stride; |
626 | row_out += out_stride; |
627 | } |
628 | return mb_h; // Num rows out == num rows in. |
629 | } |
630 | |
631 | //------------------------------------------------------------------------------ |
632 | // Export to YUVA |
633 | |
634 | static void ConvertToYUVA(const uint32_t* const src, int width, int y_pos, |
635 | const WebPDecBuffer* const output) { |
636 | const WebPYUVABuffer* const buf = &output->u.YUVA; |
637 | |
638 | // first, the luma plane |
639 | WebPConvertARGBToY(src, buf->y + y_pos * buf->y_stride, width); |
640 | |
641 | // then U/V planes |
642 | { |
643 | uint8_t* const u = buf->u + (y_pos >> 1) * buf->u_stride; |
644 | uint8_t* const v = buf->v + (y_pos >> 1) * buf->v_stride; |
645 | // even lines: store values |
646 | // odd lines: average with previous values |
647 | WebPConvertARGBToUV(src, u, v, width, !(y_pos & 1)); |
648 | } |
649 | // Lastly, store alpha if needed. |
650 | if (buf->a != NULL) { |
651 | uint8_t* const a = buf->a + y_pos * buf->a_stride; |
652 | #if defined(WORDS_BIGENDIAN) |
653 | WebPExtractAlpha((uint8_t*)src + 0, 0, width, 1, a, 0); |
654 | #else |
655 | WebPExtractAlpha((uint8_t*)src + 3, 0, width, 1, a, 0); |
656 | #endif |
657 | } |
658 | } |
659 | |
660 | static int ExportYUVA(const VP8LDecoder* const dec, int y_pos) { |
661 | WebPRescaler* const rescaler = dec->rescaler; |
662 | uint32_t* const src = (uint32_t*)rescaler->dst; |
663 | const int dst_width = rescaler->dst_width; |
664 | int num_lines_out = 0; |
665 | while (WebPRescalerHasPendingOutput(rescaler)) { |
666 | WebPRescalerExportRow(rescaler); |
667 | WebPMultARGBRow(src, dst_width, 1); |
668 | ConvertToYUVA(src, dst_width, y_pos, dec->output_); |
669 | ++y_pos; |
670 | ++num_lines_out; |
671 | } |
672 | return num_lines_out; |
673 | } |
674 | |
675 | static int EmitRescaledRowsYUVA(const VP8LDecoder* const dec, |
676 | uint8_t* in, int in_stride, int mb_h) { |
677 | int num_lines_in = 0; |
678 | int y_pos = dec->last_out_row_; |
679 | while (num_lines_in < mb_h) { |
680 | const int lines_left = mb_h - num_lines_in; |
681 | const int needed_lines = WebPRescaleNeededLines(dec->rescaler, lines_left); |
682 | int lines_imported; |
683 | WebPMultARGBRows(in, in_stride, dec->rescaler->src_width, needed_lines, 0); |
684 | lines_imported = |
685 | WebPRescalerImport(dec->rescaler, lines_left, in, in_stride); |
686 | assert(lines_imported == needed_lines); |
687 | num_lines_in += lines_imported; |
688 | in += needed_lines * in_stride; |
689 | y_pos += ExportYUVA(dec, y_pos); |
690 | } |
691 | return y_pos; |
692 | } |
693 | |
694 | static int EmitRowsYUVA(const VP8LDecoder* const dec, |
695 | const uint8_t* in, int in_stride, |
696 | int mb_w, int num_rows) { |
697 | int y_pos = dec->last_out_row_; |
698 | while (num_rows-- > 0) { |
699 | ConvertToYUVA((const uint32_t*)in, mb_w, y_pos, dec->output_); |
700 | in += in_stride; |
701 | ++y_pos; |
702 | } |
703 | return y_pos; |
704 | } |
705 | |
706 | //------------------------------------------------------------------------------ |
707 | // Cropping. |
708 | |
709 | // Sets io->mb_y, io->mb_h & io->mb_w according to start row, end row and |
710 | // crop options. Also updates the input data pointer, so that it points to the |
711 | // start of the cropped window. Note that pixels are in ARGB format even if |
712 | // 'in_data' is uint8_t*. |
713 | // Returns true if the crop window is not empty. |
714 | static int SetCropWindow(VP8Io* const io, int y_start, int y_end, |
715 | uint8_t** const in_data, int pixel_stride) { |
716 | assert(y_start < y_end); |
717 | assert(io->crop_left < io->crop_right); |
718 | if (y_end > io->crop_bottom) { |
719 | y_end = io->crop_bottom; // make sure we don't overflow on last row. |
720 | } |
721 | if (y_start < io->crop_top) { |
722 | const int delta = io->crop_top - y_start; |
723 | y_start = io->crop_top; |
724 | *in_data += delta * pixel_stride; |
725 | } |
726 | if (y_start >= y_end) return 0; // Crop window is empty. |
727 | |
728 | *in_data += io->crop_left * sizeof(uint32_t); |
729 | |
730 | io->mb_y = y_start - io->crop_top; |
731 | io->mb_w = io->crop_right - io->crop_left; |
732 | io->mb_h = y_end - y_start; |
733 | return 1; // Non-empty crop window. |
734 | } |
735 | |
736 | //------------------------------------------------------------------------------ |
737 | |
738 | static WEBP_INLINE int GetMetaIndex( |
739 | const uint32_t* const image, int xsize, int bits, int x, int y) { |
740 | if (bits == 0) return 0; |
741 | return image[xsize * (y >> bits) + (x >> bits)]; |
742 | } |
743 | |
744 | static WEBP_INLINE HTreeGroup* GetHtreeGroupForPos(VP8LMetadata* const hdr, |
745 | int x, int y) { |
746 | const int meta_index = GetMetaIndex(hdr->huffman_image_, hdr->huffman_xsize_, |
747 | hdr->huffman_subsample_bits_, x, y); |
748 | assert(meta_index < hdr->num_htree_groups_); |
749 | return hdr->htree_groups_ + meta_index; |
750 | } |
751 | |
752 | //------------------------------------------------------------------------------ |
753 | // Main loop, with custom row-processing function |
754 | |
755 | typedef void (*ProcessRowsFunc)(VP8LDecoder* const dec, int row); |
756 | |
757 | static void ApplyInverseTransforms(VP8LDecoder* const dec, |
758 | int start_row, int num_rows, |
759 | const uint32_t* const rows) { |
760 | int n = dec->next_transform_; |
761 | const int cache_pixs = dec->width_ * num_rows; |
762 | const int end_row = start_row + num_rows; |
763 | const uint32_t* rows_in = rows; |
764 | uint32_t* const rows_out = dec->argb_cache_; |
765 | |
766 | // Inverse transforms. |
767 | while (n-- > 0) { |
768 | VP8LTransform* const transform = &dec->transforms_[n]; |
769 | VP8LInverseTransform(transform, start_row, end_row, rows_in, rows_out); |
770 | rows_in = rows_out; |
771 | } |
772 | if (rows_in != rows_out) { |
773 | // No transform called, hence just copy. |
774 | memcpy(rows_out, rows_in, cache_pixs * sizeof(*rows_out)); |
775 | } |
776 | } |
777 | |
778 | // Processes (transforms, scales & color-converts) the rows decoded after the |
779 | // last call. |
780 | static void ProcessRows(VP8LDecoder* const dec, int row) { |
781 | const uint32_t* const rows = dec->pixels_ + dec->width_ * dec->last_row_; |
782 | const int num_rows = row - dec->last_row_; |
783 | |
784 | assert(row <= dec->io_->crop_bottom); |
785 | // We can't process more than NUM_ARGB_CACHE_ROWS at a time (that's the size |
786 | // of argb_cache_), but we currently don't need more than that. |
787 | assert(num_rows <= NUM_ARGB_CACHE_ROWS); |
788 | if (num_rows > 0) { // Emit output. |
789 | VP8Io* const io = dec->io_; |
790 | uint8_t* rows_data = (uint8_t*)dec->argb_cache_; |
791 | const int in_stride = io->width * sizeof(uint32_t); // in unit of RGBA |
792 | ApplyInverseTransforms(dec, dec->last_row_, num_rows, rows); |
793 | if (!SetCropWindow(io, dec->last_row_, row, &rows_data, in_stride)) { |
794 | // Nothing to output (this time). |
795 | } else { |
796 | const WebPDecBuffer* const output = dec->output_; |
797 | if (WebPIsRGBMode(output->colorspace)) { // convert to RGBA |
798 | const WebPRGBABuffer* const buf = &output->u.RGBA; |
799 | uint8_t* const rgba = buf->rgba + dec->last_out_row_ * buf->stride; |
800 | const int num_rows_out = |
801 | #if !defined(WEBP_REDUCE_SIZE) |
802 | io->use_scaling ? |
803 | EmitRescaledRowsRGBA(dec, rows_data, in_stride, io->mb_h, |
804 | rgba, buf->stride) : |
805 | #endif // WEBP_REDUCE_SIZE |
806 | EmitRows(output->colorspace, rows_data, in_stride, |
807 | io->mb_w, io->mb_h, rgba, buf->stride); |
808 | // Update 'last_out_row_'. |
809 | dec->last_out_row_ += num_rows_out; |
810 | } else { // convert to YUVA |
811 | dec->last_out_row_ = io->use_scaling ? |
812 | EmitRescaledRowsYUVA(dec, rows_data, in_stride, io->mb_h) : |
813 | EmitRowsYUVA(dec, rows_data, in_stride, io->mb_w, io->mb_h); |
814 | } |
815 | assert(dec->last_out_row_ <= output->height); |
816 | } |
817 | } |
818 | |
819 | // Update 'last_row_'. |
820 | dec->last_row_ = row; |
821 | assert(dec->last_row_ <= dec->height_); |
822 | } |
823 | |
824 | // Row-processing for the special case when alpha data contains only one |
825 | // transform (color indexing), and trivial non-green literals. |
826 | static int Is8bOptimizable(const VP8LMetadata* const hdr) { |
827 | int i; |
828 | if (hdr->color_cache_size_ > 0) return 0; |
829 | // When the Huffman tree contains only one symbol, we can skip the |
830 | // call to ReadSymbol() for red/blue/alpha channels. |
831 | for (i = 0; i < hdr->num_htree_groups_; ++i) { |
832 | HuffmanCode** const htrees = hdr->htree_groups_[i].htrees; |
833 | if (htrees[RED][0].bits > 0) return 0; |
834 | if (htrees[BLUE][0].bits > 0) return 0; |
835 | if (htrees[ALPHA][0].bits > 0) return 0; |
836 | } |
837 | return 1; |
838 | } |
839 | |
840 | static void AlphaApplyFilter(ALPHDecoder* const alph_dec, |
841 | int first_row, int last_row, |
842 | uint8_t* out, int stride) { |
843 | if (alph_dec->filter_ != WEBP_FILTER_NONE) { |
844 | int y; |
845 | const uint8_t* prev_line = alph_dec->prev_line_; |
846 | assert(WebPUnfilters[alph_dec->filter_] != NULL); |
847 | for (y = first_row; y < last_row; ++y) { |
848 | WebPUnfilters[alph_dec->filter_](prev_line, out, out, stride); |
849 | prev_line = out; |
850 | out += stride; |
851 | } |
852 | alph_dec->prev_line_ = prev_line; |
853 | } |
854 | } |
855 | |
856 | static void (VP8LDecoder* const dec, int last_row) { |
857 | // For vertical and gradient filtering, we need to decode the part above the |
858 | // crop_top row, in order to have the correct spatial predictors. |
859 | ALPHDecoder* const alph_dec = (ALPHDecoder*)dec->io_->opaque; |
860 | const int top_row = |
861 | (alph_dec->filter_ == WEBP_FILTER_NONE || |
862 | alph_dec->filter_ == WEBP_FILTER_HORIZONTAL) ? dec->io_->crop_top |
863 | : dec->last_row_; |
864 | const int first_row = (dec->last_row_ < top_row) ? top_row : dec->last_row_; |
865 | assert(last_row <= dec->io_->crop_bottom); |
866 | if (last_row > first_row) { |
867 | // Special method for paletted alpha data. We only process the cropped area. |
868 | const int width = dec->io_->width; |
869 | uint8_t* out = alph_dec->output_ + width * first_row; |
870 | const uint8_t* const in = |
871 | (uint8_t*)dec->pixels_ + dec->width_ * first_row; |
872 | VP8LTransform* const transform = &dec->transforms_[0]; |
873 | assert(dec->next_transform_ == 1); |
874 | assert(transform->type_ == COLOR_INDEXING_TRANSFORM); |
875 | VP8LColorIndexInverseTransformAlpha(transform, first_row, last_row, |
876 | in, out); |
877 | AlphaApplyFilter(alph_dec, first_row, last_row, out, width); |
878 | } |
879 | dec->last_row_ = dec->last_out_row_ = last_row; |
880 | } |
881 | |
882 | //------------------------------------------------------------------------------ |
883 | // Helper functions for fast pattern copy (8b and 32b) |
884 | |
885 | // cyclic rotation of pattern word |
886 | static WEBP_INLINE uint32_t Rotate8b(uint32_t V) { |
887 | #if defined(WORDS_BIGENDIAN) |
888 | return ((V & 0xff000000u) >> 24) | (V << 8); |
889 | #else |
890 | return ((V & 0xffu) << 24) | (V >> 8); |
891 | #endif |
892 | } |
893 | |
894 | // copy 1, 2 or 4-bytes pattern |
895 | static WEBP_INLINE void CopySmallPattern8b(const uint8_t* src, uint8_t* dst, |
896 | int length, uint32_t pattern) { |
897 | int i; |
898 | // align 'dst' to 4-bytes boundary. Adjust the pattern along the way. |
899 | while ((uintptr_t)dst & 3) { |
900 | *dst++ = *src++; |
901 | pattern = Rotate8b(pattern); |
902 | --length; |
903 | } |
904 | // Copy the pattern 4 bytes at a time. |
905 | for (i = 0; i < (length >> 2); ++i) { |
906 | ((uint32_t*)dst)[i] = pattern; |
907 | } |
908 | // Finish with left-overs. 'pattern' is still correctly positioned, |
909 | // so no Rotate8b() call is needed. |
910 | for (i <<= 2; i < length; ++i) { |
911 | dst[i] = src[i]; |
912 | } |
913 | } |
914 | |
915 | static WEBP_INLINE void CopyBlock8b(uint8_t* const dst, int dist, int length) { |
916 | const uint8_t* src = dst - dist; |
917 | if (length >= 8) { |
918 | uint32_t pattern = 0; |
919 | switch (dist) { |
920 | case 1: |
921 | pattern = src[0]; |
922 | #if defined(__arm__) || defined(_M_ARM) // arm doesn't like multiply that much |
923 | pattern |= pattern << 8; |
924 | pattern |= pattern << 16; |
925 | #elif defined(WEBP_USE_MIPS_DSP_R2) |
926 | __asm__ volatile ("replv.qb %0, %0" : "+r" (pattern)); |
927 | #else |
928 | pattern = 0x01010101u * pattern; |
929 | #endif |
930 | break; |
931 | case 2: |
932 | #if !defined(WORDS_BIGENDIAN) |
933 | memcpy(&pattern, src, sizeof(uint16_t)); |
934 | #else |
935 | pattern = ((uint32_t)src[0] << 8) | src[1]; |
936 | #endif |
937 | #if defined(__arm__) || defined(_M_ARM) |
938 | pattern |= pattern << 16; |
939 | #elif defined(WEBP_USE_MIPS_DSP_R2) |
940 | __asm__ volatile ("replv.ph %0, %0" : "+r" (pattern)); |
941 | #else |
942 | pattern = 0x00010001u * pattern; |
943 | #endif |
944 | break; |
945 | case 4: |
946 | memcpy(&pattern, src, sizeof(uint32_t)); |
947 | break; |
948 | default: |
949 | goto Copy; |
950 | break; |
951 | } |
952 | CopySmallPattern8b(src, dst, length, pattern); |
953 | return; |
954 | } |
955 | Copy: |
956 | if (dist >= length) { // no overlap -> use memcpy() |
957 | memcpy(dst, src, length * sizeof(*dst)); |
958 | } else { |
959 | int i; |
960 | for (i = 0; i < length; ++i) dst[i] = src[i]; |
961 | } |
962 | } |
963 | |
964 | // copy pattern of 1 or 2 uint32_t's |
965 | static WEBP_INLINE void CopySmallPattern32b(const uint32_t* src, |
966 | uint32_t* dst, |
967 | int length, uint64_t pattern) { |
968 | int i; |
969 | if ((uintptr_t)dst & 4) { // Align 'dst' to 8-bytes boundary. |
970 | *dst++ = *src++; |
971 | pattern = (pattern >> 32) | (pattern << 32); |
972 | --length; |
973 | } |
974 | assert(0 == ((uintptr_t)dst & 7)); |
975 | for (i = 0; i < (length >> 1); ++i) { |
976 | ((uint64_t*)dst)[i] = pattern; // Copy the pattern 8 bytes at a time. |
977 | } |
978 | if (length & 1) { // Finish with left-over. |
979 | dst[i << 1] = src[i << 1]; |
980 | } |
981 | } |
982 | |
983 | static WEBP_INLINE void CopyBlock32b(uint32_t* const dst, |
984 | int dist, int length) { |
985 | const uint32_t* const src = dst - dist; |
986 | if (dist <= 2 && length >= 4 && ((uintptr_t)dst & 3) == 0) { |
987 | uint64_t pattern; |
988 | if (dist == 1) { |
989 | pattern = (uint64_t)src[0]; |
990 | pattern |= pattern << 32; |
991 | } else { |
992 | memcpy(&pattern, src, sizeof(pattern)); |
993 | } |
994 | CopySmallPattern32b(src, dst, length, pattern); |
995 | } else if (dist >= length) { // no overlap |
996 | memcpy(dst, src, length * sizeof(*dst)); |
997 | } else { |
998 | int i; |
999 | for (i = 0; i < length; ++i) dst[i] = src[i]; |
1000 | } |
1001 | } |
1002 | |
1003 | //------------------------------------------------------------------------------ |
1004 | |
1005 | static int DecodeAlphaData(VP8LDecoder* const dec, uint8_t* const data, |
1006 | int width, int height, int last_row) { |
1007 | int ok = 1; |
1008 | int row = dec->last_pixel_ / width; |
1009 | int col = dec->last_pixel_ % width; |
1010 | VP8LBitReader* const br = &dec->br_; |
1011 | VP8LMetadata* const hdr = &dec->hdr_; |
1012 | int pos = dec->last_pixel_; // current position |
1013 | const int end = width * height; // End of data |
1014 | const int last = width * last_row; // Last pixel to decode |
1015 | const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES; |
1016 | const int mask = hdr->huffman_mask_; |
1017 | const HTreeGroup* htree_group = |
1018 | (pos < last) ? GetHtreeGroupForPos(hdr, col, row) : NULL; |
1019 | assert(pos <= end); |
1020 | assert(last_row <= height); |
1021 | assert(Is8bOptimizable(hdr)); |
1022 | |
1023 | while (!br->eos_ && pos < last) { |
1024 | int code; |
1025 | // Only update when changing tile. |
1026 | if ((col & mask) == 0) { |
1027 | htree_group = GetHtreeGroupForPos(hdr, col, row); |
1028 | } |
1029 | assert(htree_group != NULL); |
1030 | VP8LFillBitWindow(br); |
1031 | code = ReadSymbol(htree_group->htrees[GREEN], br); |
1032 | if (code < NUM_LITERAL_CODES) { // Literal |
1033 | data[pos] = code; |
1034 | ++pos; |
1035 | ++col; |
1036 | if (col >= width) { |
1037 | col = 0; |
1038 | ++row; |
1039 | if (row <= last_row && (row % NUM_ARGB_CACHE_ROWS == 0)) { |
1040 | ExtractPalettedAlphaRows(dec, row); |
1041 | } |
1042 | } |
1043 | } else if (code < len_code_limit) { // Backward reference |
1044 | int dist_code, dist; |
1045 | const int length_sym = code - NUM_LITERAL_CODES; |
1046 | const int length = GetCopyLength(length_sym, br); |
1047 | const int dist_symbol = ReadSymbol(htree_group->htrees[DIST], br); |
1048 | VP8LFillBitWindow(br); |
1049 | dist_code = GetCopyDistance(dist_symbol, br); |
1050 | dist = PlaneCodeToDistance(width, dist_code); |
1051 | if (pos >= dist && end - pos >= length) { |
1052 | CopyBlock8b(data + pos, dist, length); |
1053 | } else { |
1054 | ok = 0; |
1055 | goto End; |
1056 | } |
1057 | pos += length; |
1058 | col += length; |
1059 | while (col >= width) { |
1060 | col -= width; |
1061 | ++row; |
1062 | if (row <= last_row && (row % NUM_ARGB_CACHE_ROWS == 0)) { |
1063 | ExtractPalettedAlphaRows(dec, row); |
1064 | } |
1065 | } |
1066 | if (pos < last && (col & mask)) { |
1067 | htree_group = GetHtreeGroupForPos(hdr, col, row); |
1068 | } |
1069 | } else { // Not reached |
1070 | ok = 0; |
1071 | goto End; |
1072 | } |
1073 | br->eos_ = VP8LIsEndOfStream(br); |
1074 | } |
1075 | // Process the remaining rows corresponding to last row-block. |
1076 | ExtractPalettedAlphaRows(dec, row > last_row ? last_row : row); |
1077 | |
1078 | End: |
1079 | br->eos_ = VP8LIsEndOfStream(br); |
1080 | if (!ok || (br->eos_ && pos < end)) { |
1081 | ok = 0; |
1082 | dec->status_ = br->eos_ ? VP8_STATUS_SUSPENDED |
1083 | : VP8_STATUS_BITSTREAM_ERROR; |
1084 | } else { |
1085 | dec->last_pixel_ = pos; |
1086 | } |
1087 | return ok; |
1088 | } |
1089 | |
1090 | static void SaveState(VP8LDecoder* const dec, int last_pixel) { |
1091 | assert(dec->incremental_); |
1092 | dec->saved_br_ = dec->br_; |
1093 | dec->saved_last_pixel_ = last_pixel; |
1094 | if (dec->hdr_.color_cache_size_ > 0) { |
1095 | VP8LColorCacheCopy(&dec->hdr_.color_cache_, &dec->hdr_.saved_color_cache_); |
1096 | } |
1097 | } |
1098 | |
1099 | static void RestoreState(VP8LDecoder* const dec) { |
1100 | assert(dec->br_.eos_); |
1101 | dec->status_ = VP8_STATUS_SUSPENDED; |
1102 | dec->br_ = dec->saved_br_; |
1103 | dec->last_pixel_ = dec->saved_last_pixel_; |
1104 | if (dec->hdr_.color_cache_size_ > 0) { |
1105 | VP8LColorCacheCopy(&dec->hdr_.saved_color_cache_, &dec->hdr_.color_cache_); |
1106 | } |
1107 | } |
1108 | |
1109 | #define SYNC_EVERY_N_ROWS 8 // minimum number of rows between check-points |
1110 | static int DecodeImageData(VP8LDecoder* const dec, uint32_t* const data, |
1111 | int width, int height, int last_row, |
1112 | ProcessRowsFunc process_func) { |
1113 | int row = dec->last_pixel_ / width; |
1114 | int col = dec->last_pixel_ % width; |
1115 | VP8LBitReader* const br = &dec->br_; |
1116 | VP8LMetadata* const hdr = &dec->hdr_; |
1117 | uint32_t* src = data + dec->last_pixel_; |
1118 | uint32_t* last_cached = src; |
1119 | uint32_t* const src_end = data + width * height; // End of data |
1120 | uint32_t* const src_last = data + width * last_row; // Last pixel to decode |
1121 | const int len_code_limit = NUM_LITERAL_CODES + NUM_LENGTH_CODES; |
1122 | const int color_cache_limit = len_code_limit + hdr->color_cache_size_; |
1123 | int next_sync_row = dec->incremental_ ? row : 1 << 24; |
1124 | VP8LColorCache* const color_cache = |
1125 | (hdr->color_cache_size_ > 0) ? &hdr->color_cache_ : NULL; |
1126 | const int mask = hdr->huffman_mask_; |
1127 | const HTreeGroup* htree_group = |
1128 | (src < src_last) ? GetHtreeGroupForPos(hdr, col, row) : NULL; |
1129 | assert(dec->last_row_ < last_row); |
1130 | assert(src_last <= src_end); |
1131 | |
1132 | while (src < src_last) { |
1133 | int code; |
1134 | if (row >= next_sync_row) { |
1135 | SaveState(dec, (int)(src - data)); |
1136 | next_sync_row = row + SYNC_EVERY_N_ROWS; |
1137 | } |
1138 | // Only update when changing tile. Note we could use this test: |
1139 | // if "((((prev_col ^ col) | prev_row ^ row)) > mask)" -> tile changed |
1140 | // but that's actually slower and needs storing the previous col/row. |
1141 | if ((col & mask) == 0) { |
1142 | htree_group = GetHtreeGroupForPos(hdr, col, row); |
1143 | } |
1144 | assert(htree_group != NULL); |
1145 | if (htree_group->is_trivial_code) { |
1146 | *src = htree_group->literal_arb; |
1147 | goto AdvanceByOne; |
1148 | } |
1149 | VP8LFillBitWindow(br); |
1150 | if (htree_group->use_packed_table) { |
1151 | code = ReadPackedSymbols(htree_group, br, src); |
1152 | if (VP8LIsEndOfStream(br)) break; |
1153 | if (code == PACKED_NON_LITERAL_CODE) goto AdvanceByOne; |
1154 | } else { |
1155 | code = ReadSymbol(htree_group->htrees[GREEN], br); |
1156 | } |
1157 | if (VP8LIsEndOfStream(br)) break; |
1158 | if (code < NUM_LITERAL_CODES) { // Literal |
1159 | if (htree_group->is_trivial_literal) { |
1160 | *src = htree_group->literal_arb | (code << 8); |
1161 | } else { |
1162 | int red, blue, alpha; |
1163 | red = ReadSymbol(htree_group->htrees[RED], br); |
1164 | VP8LFillBitWindow(br); |
1165 | blue = ReadSymbol(htree_group->htrees[BLUE], br); |
1166 | alpha = ReadSymbol(htree_group->htrees[ALPHA], br); |
1167 | if (VP8LIsEndOfStream(br)) break; |
1168 | *src = ((uint32_t)alpha << 24) | (red << 16) | (code << 8) | blue; |
1169 | } |
1170 | AdvanceByOne: |
1171 | ++src; |
1172 | ++col; |
1173 | if (col >= width) { |
1174 | col = 0; |
1175 | ++row; |
1176 | if (process_func != NULL) { |
1177 | if (row <= last_row && (row % NUM_ARGB_CACHE_ROWS == 0)) { |
1178 | process_func(dec, row); |
1179 | } |
1180 | } |
1181 | if (color_cache != NULL) { |
1182 | while (last_cached < src) { |
1183 | VP8LColorCacheInsert(color_cache, *last_cached++); |
1184 | } |
1185 | } |
1186 | } |
1187 | } else if (code < len_code_limit) { // Backward reference |
1188 | int dist_code, dist; |
1189 | const int length_sym = code - NUM_LITERAL_CODES; |
1190 | const int length = GetCopyLength(length_sym, br); |
1191 | const int dist_symbol = ReadSymbol(htree_group->htrees[DIST], br); |
1192 | VP8LFillBitWindow(br); |
1193 | dist_code = GetCopyDistance(dist_symbol, br); |
1194 | dist = PlaneCodeToDistance(width, dist_code); |
1195 | |
1196 | if (VP8LIsEndOfStream(br)) break; |
1197 | if (src - data < (ptrdiff_t)dist || src_end - src < (ptrdiff_t)length) { |
1198 | goto Error; |
1199 | } else { |
1200 | CopyBlock32b(src, dist, length); |
1201 | } |
1202 | src += length; |
1203 | col += length; |
1204 | while (col >= width) { |
1205 | col -= width; |
1206 | ++row; |
1207 | if (process_func != NULL) { |
1208 | if (row <= last_row && (row % NUM_ARGB_CACHE_ROWS == 0)) { |
1209 | process_func(dec, row); |
1210 | } |
1211 | } |
1212 | } |
1213 | // Because of the check done above (before 'src' was incremented by |
1214 | // 'length'), the following holds true. |
1215 | assert(src <= src_end); |
1216 | if (col & mask) htree_group = GetHtreeGroupForPos(hdr, col, row); |
1217 | if (color_cache != NULL) { |
1218 | while (last_cached < src) { |
1219 | VP8LColorCacheInsert(color_cache, *last_cached++); |
1220 | } |
1221 | } |
1222 | } else if (code < color_cache_limit) { // Color cache |
1223 | const int key = code - len_code_limit; |
1224 | assert(color_cache != NULL); |
1225 | while (last_cached < src) { |
1226 | VP8LColorCacheInsert(color_cache, *last_cached++); |
1227 | } |
1228 | *src = VP8LColorCacheLookup(color_cache, key); |
1229 | goto AdvanceByOne; |
1230 | } else { // Not reached |
1231 | goto Error; |
1232 | } |
1233 | } |
1234 | |
1235 | br->eos_ = VP8LIsEndOfStream(br); |
1236 | if (dec->incremental_ && br->eos_ && src < src_end) { |
1237 | RestoreState(dec); |
1238 | } else if (!br->eos_) { |
1239 | // Process the remaining rows corresponding to last row-block. |
1240 | if (process_func != NULL) { |
1241 | process_func(dec, row > last_row ? last_row : row); |
1242 | } |
1243 | dec->status_ = VP8_STATUS_OK; |
1244 | dec->last_pixel_ = (int)(src - data); // end-of-scan marker |
1245 | } else { |
1246 | // if not incremental, and we are past the end of buffer (eos_=1), then this |
1247 | // is a real bitstream error. |
1248 | goto Error; |
1249 | } |
1250 | return 1; |
1251 | |
1252 | Error: |
1253 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
1254 | return 0; |
1255 | } |
1256 | |
1257 | // ----------------------------------------------------------------------------- |
1258 | // VP8LTransform |
1259 | |
1260 | static void ClearTransform(VP8LTransform* const transform) { |
1261 | WebPSafeFree(transform->data_); |
1262 | transform->data_ = NULL; |
1263 | } |
1264 | |
1265 | // For security reason, we need to remap the color map to span |
1266 | // the total possible bundled values, and not just the num_colors. |
1267 | static int ExpandColorMap(int num_colors, VP8LTransform* const transform) { |
1268 | int i; |
1269 | const int final_num_colors = 1 << (8 >> transform->bits_); |
1270 | uint32_t* const new_color_map = |
1271 | (uint32_t*)WebPSafeMalloc((uint64_t)final_num_colors, |
1272 | sizeof(*new_color_map)); |
1273 | if (new_color_map == NULL) { |
1274 | return 0; |
1275 | } else { |
1276 | uint8_t* const data = (uint8_t*)transform->data_; |
1277 | uint8_t* const new_data = (uint8_t*)new_color_map; |
1278 | new_color_map[0] = transform->data_[0]; |
1279 | for (i = 4; i < 4 * num_colors; ++i) { |
1280 | // Equivalent to AddPixelEq(), on a byte-basis. |
1281 | new_data[i] = (data[i] + new_data[i - 4]) & 0xff; |
1282 | } |
1283 | for (; i < 4 * final_num_colors; ++i) { |
1284 | new_data[i] = 0; // black tail. |
1285 | } |
1286 | WebPSafeFree(transform->data_); |
1287 | transform->data_ = new_color_map; |
1288 | } |
1289 | return 1; |
1290 | } |
1291 | |
1292 | static int ReadTransform(int* const xsize, int const* ysize, |
1293 | VP8LDecoder* const dec) { |
1294 | int ok = 1; |
1295 | VP8LBitReader* const br = &dec->br_; |
1296 | VP8LTransform* transform = &dec->transforms_[dec->next_transform_]; |
1297 | const VP8LImageTransformType type = |
1298 | (VP8LImageTransformType)VP8LReadBits(br, 2); |
1299 | |
1300 | // Each transform type can only be present once in the stream. |
1301 | if (dec->transforms_seen_ & (1U << type)) { |
1302 | return 0; // Already there, let's not accept the second same transform. |
1303 | } |
1304 | dec->transforms_seen_ |= (1U << type); |
1305 | |
1306 | transform->type_ = type; |
1307 | transform->xsize_ = *xsize; |
1308 | transform->ysize_ = *ysize; |
1309 | transform->data_ = NULL; |
1310 | ++dec->next_transform_; |
1311 | assert(dec->next_transform_ <= NUM_TRANSFORMS); |
1312 | |
1313 | switch (type) { |
1314 | case PREDICTOR_TRANSFORM: |
1315 | case CROSS_COLOR_TRANSFORM: |
1316 | transform->bits_ = VP8LReadBits(br, 3) + 2; |
1317 | ok = DecodeImageStream(VP8LSubSampleSize(transform->xsize_, |
1318 | transform->bits_), |
1319 | VP8LSubSampleSize(transform->ysize_, |
1320 | transform->bits_), |
1321 | 0, dec, &transform->data_); |
1322 | break; |
1323 | case COLOR_INDEXING_TRANSFORM: { |
1324 | const int num_colors = VP8LReadBits(br, 8) + 1; |
1325 | const int bits = (num_colors > 16) ? 0 |
1326 | : (num_colors > 4) ? 1 |
1327 | : (num_colors > 2) ? 2 |
1328 | : 3; |
1329 | *xsize = VP8LSubSampleSize(transform->xsize_, bits); |
1330 | transform->bits_ = bits; |
1331 | ok = DecodeImageStream(num_colors, 1, 0, dec, &transform->data_); |
1332 | ok = ok && ExpandColorMap(num_colors, transform); |
1333 | break; |
1334 | } |
1335 | case SUBTRACT_GREEN: |
1336 | break; |
1337 | default: |
1338 | assert(0); // can't happen |
1339 | break; |
1340 | } |
1341 | |
1342 | return ok; |
1343 | } |
1344 | |
1345 | // ----------------------------------------------------------------------------- |
1346 | // VP8LMetadata |
1347 | |
1348 | static void InitMetadata(VP8LMetadata* const hdr) { |
1349 | assert(hdr != NULL); |
1350 | memset(hdr, 0, sizeof(*hdr)); |
1351 | } |
1352 | |
1353 | static void ClearMetadata(VP8LMetadata* const hdr) { |
1354 | assert(hdr != NULL); |
1355 | |
1356 | WebPSafeFree(hdr->huffman_image_); |
1357 | WebPSafeFree(hdr->huffman_tables_); |
1358 | VP8LHtreeGroupsFree(hdr->htree_groups_); |
1359 | VP8LColorCacheClear(&hdr->color_cache_); |
1360 | VP8LColorCacheClear(&hdr->saved_color_cache_); |
1361 | InitMetadata(hdr); |
1362 | } |
1363 | |
1364 | // ----------------------------------------------------------------------------- |
1365 | // VP8LDecoder |
1366 | |
1367 | VP8LDecoder* VP8LNew(void) { |
1368 | VP8LDecoder* const dec = (VP8LDecoder*)WebPSafeCalloc(1ULL, sizeof(*dec)); |
1369 | if (dec == NULL) return NULL; |
1370 | dec->status_ = VP8_STATUS_OK; |
1371 | dec->state_ = READ_DIM; |
1372 | |
1373 | VP8LDspInit(); // Init critical function pointers. |
1374 | |
1375 | return dec; |
1376 | } |
1377 | |
1378 | void VP8LClear(VP8LDecoder* const dec) { |
1379 | int i; |
1380 | if (dec == NULL) return; |
1381 | ClearMetadata(&dec->hdr_); |
1382 | |
1383 | WebPSafeFree(dec->pixels_); |
1384 | dec->pixels_ = NULL; |
1385 | for (i = 0; i < dec->next_transform_; ++i) { |
1386 | ClearTransform(&dec->transforms_[i]); |
1387 | } |
1388 | dec->next_transform_ = 0; |
1389 | dec->transforms_seen_ = 0; |
1390 | |
1391 | WebPSafeFree(dec->rescaler_memory); |
1392 | dec->rescaler_memory = NULL; |
1393 | |
1394 | dec->output_ = NULL; // leave no trace behind |
1395 | } |
1396 | |
1397 | void VP8LDelete(VP8LDecoder* const dec) { |
1398 | if (dec != NULL) { |
1399 | VP8LClear(dec); |
1400 | WebPSafeFree(dec); |
1401 | } |
1402 | } |
1403 | |
1404 | static void UpdateDecoder(VP8LDecoder* const dec, int width, int height) { |
1405 | VP8LMetadata* const hdr = &dec->hdr_; |
1406 | const int num_bits = hdr->huffman_subsample_bits_; |
1407 | dec->width_ = width; |
1408 | dec->height_ = height; |
1409 | |
1410 | hdr->huffman_xsize_ = VP8LSubSampleSize(width, num_bits); |
1411 | hdr->huffman_mask_ = (num_bits == 0) ? ~0 : (1 << num_bits) - 1; |
1412 | } |
1413 | |
1414 | static int DecodeImageStream(int xsize, int ysize, |
1415 | int is_level0, |
1416 | VP8LDecoder* const dec, |
1417 | uint32_t** const decoded_data) { |
1418 | int ok = 1; |
1419 | int transform_xsize = xsize; |
1420 | int transform_ysize = ysize; |
1421 | VP8LBitReader* const br = &dec->br_; |
1422 | VP8LMetadata* const hdr = &dec->hdr_; |
1423 | uint32_t* data = NULL; |
1424 | int color_cache_bits = 0; |
1425 | |
1426 | // Read the transforms (may recurse). |
1427 | if (is_level0) { |
1428 | while (ok && VP8LReadBits(br, 1)) { |
1429 | ok = ReadTransform(&transform_xsize, &transform_ysize, dec); |
1430 | } |
1431 | } |
1432 | |
1433 | // Color cache |
1434 | if (ok && VP8LReadBits(br, 1)) { |
1435 | color_cache_bits = VP8LReadBits(br, 4); |
1436 | ok = (color_cache_bits >= 1 && color_cache_bits <= MAX_CACHE_BITS); |
1437 | if (!ok) { |
1438 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
1439 | goto End; |
1440 | } |
1441 | } |
1442 | |
1443 | // Read the Huffman codes (may recurse). |
1444 | ok = ok && ReadHuffmanCodes(dec, transform_xsize, transform_ysize, |
1445 | color_cache_bits, is_level0); |
1446 | if (!ok) { |
1447 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
1448 | goto End; |
1449 | } |
1450 | |
1451 | // Finish setting up the color-cache |
1452 | if (color_cache_bits > 0) { |
1453 | hdr->color_cache_size_ = 1 << color_cache_bits; |
1454 | if (!VP8LColorCacheInit(&hdr->color_cache_, color_cache_bits)) { |
1455 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
1456 | ok = 0; |
1457 | goto End; |
1458 | } |
1459 | } else { |
1460 | hdr->color_cache_size_ = 0; |
1461 | } |
1462 | UpdateDecoder(dec, transform_xsize, transform_ysize); |
1463 | |
1464 | if (is_level0) { // level 0 complete |
1465 | dec->state_ = READ_HDR; |
1466 | goto End; |
1467 | } |
1468 | |
1469 | { |
1470 | const uint64_t total_size = (uint64_t)transform_xsize * transform_ysize; |
1471 | data = (uint32_t*)WebPSafeMalloc(total_size, sizeof(*data)); |
1472 | if (data == NULL) { |
1473 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
1474 | ok = 0; |
1475 | goto End; |
1476 | } |
1477 | } |
1478 | |
1479 | // Use the Huffman trees to decode the LZ77 encoded data. |
1480 | ok = DecodeImageData(dec, data, transform_xsize, transform_ysize, |
1481 | transform_ysize, NULL); |
1482 | ok = ok && !br->eos_; |
1483 | |
1484 | End: |
1485 | if (!ok) { |
1486 | WebPSafeFree(data); |
1487 | ClearMetadata(hdr); |
1488 | } else { |
1489 | if (decoded_data != NULL) { |
1490 | *decoded_data = data; |
1491 | } else { |
1492 | // We allocate image data in this function only for transforms. At level 0 |
1493 | // (that is: not the transforms), we shouldn't have allocated anything. |
1494 | assert(data == NULL); |
1495 | assert(is_level0); |
1496 | } |
1497 | dec->last_pixel_ = 0; // Reset for future DECODE_DATA_FUNC() calls. |
1498 | if (!is_level0) ClearMetadata(hdr); // Clean up temporary data behind. |
1499 | } |
1500 | return ok; |
1501 | } |
1502 | |
1503 | //------------------------------------------------------------------------------ |
1504 | // Allocate internal buffers dec->pixels_ and dec->argb_cache_. |
1505 | static int AllocateInternalBuffers32b(VP8LDecoder* const dec, int final_width) { |
1506 | const uint64_t num_pixels = (uint64_t)dec->width_ * dec->height_; |
1507 | // Scratch buffer corresponding to top-prediction row for transforming the |
1508 | // first row in the row-blocks. Not needed for paletted alpha. |
1509 | const uint64_t cache_top_pixels = (uint16_t)final_width; |
1510 | // Scratch buffer for temporary BGRA storage. Not needed for paletted alpha. |
1511 | const uint64_t cache_pixels = (uint64_t)final_width * NUM_ARGB_CACHE_ROWS; |
1512 | const uint64_t total_num_pixels = |
1513 | num_pixels + cache_top_pixels + cache_pixels; |
1514 | |
1515 | assert(dec->width_ <= final_width); |
1516 | dec->pixels_ = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint32_t)); |
1517 | if (dec->pixels_ == NULL) { |
1518 | dec->argb_cache_ = NULL; // for sanity check |
1519 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
1520 | return 0; |
1521 | } |
1522 | dec->argb_cache_ = dec->pixels_ + num_pixels + cache_top_pixels; |
1523 | return 1; |
1524 | } |
1525 | |
1526 | static int AllocateInternalBuffers8b(VP8LDecoder* const dec) { |
1527 | const uint64_t total_num_pixels = (uint64_t)dec->width_ * dec->height_; |
1528 | dec->argb_cache_ = NULL; // for sanity check |
1529 | dec->pixels_ = (uint32_t*)WebPSafeMalloc(total_num_pixels, sizeof(uint8_t)); |
1530 | if (dec->pixels_ == NULL) { |
1531 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
1532 | return 0; |
1533 | } |
1534 | return 1; |
1535 | } |
1536 | |
1537 | //------------------------------------------------------------------------------ |
1538 | |
1539 | // Special row-processing that only stores the alpha data. |
1540 | static void (VP8LDecoder* const dec, int last_row) { |
1541 | int cur_row = dec->last_row_; |
1542 | int num_rows = last_row - cur_row; |
1543 | const uint32_t* in = dec->pixels_ + dec->width_ * cur_row; |
1544 | |
1545 | assert(last_row <= dec->io_->crop_bottom); |
1546 | while (num_rows > 0) { |
1547 | const int num_rows_to_process = |
1548 | (num_rows > NUM_ARGB_CACHE_ROWS) ? NUM_ARGB_CACHE_ROWS : num_rows; |
1549 | // Extract alpha (which is stored in the green plane). |
1550 | ALPHDecoder* const alph_dec = (ALPHDecoder*)dec->io_->opaque; |
1551 | uint8_t* const output = alph_dec->output_; |
1552 | const int width = dec->io_->width; // the final width (!= dec->width_) |
1553 | const int cache_pixs = width * num_rows_to_process; |
1554 | uint8_t* const dst = output + width * cur_row; |
1555 | const uint32_t* const src = dec->argb_cache_; |
1556 | ApplyInverseTransforms(dec, cur_row, num_rows_to_process, in); |
1557 | WebPExtractGreen(src, dst, cache_pixs); |
1558 | AlphaApplyFilter(alph_dec, |
1559 | cur_row, cur_row + num_rows_to_process, dst, width); |
1560 | num_rows -= num_rows_to_process; |
1561 | in += num_rows_to_process * dec->width_; |
1562 | cur_row += num_rows_to_process; |
1563 | } |
1564 | assert(cur_row == last_row); |
1565 | dec->last_row_ = dec->last_out_row_ = last_row; |
1566 | } |
1567 | |
1568 | int (ALPHDecoder* const alph_dec, |
1569 | const uint8_t* const data, size_t data_size) { |
1570 | int ok = 0; |
1571 | VP8LDecoder* dec = VP8LNew(); |
1572 | |
1573 | if (dec == NULL) return 0; |
1574 | |
1575 | assert(alph_dec != NULL); |
1576 | |
1577 | dec->width_ = alph_dec->width_; |
1578 | dec->height_ = alph_dec->height_; |
1579 | dec->io_ = &alph_dec->io_; |
1580 | dec->io_->opaque = alph_dec; |
1581 | dec->io_->width = alph_dec->width_; |
1582 | dec->io_->height = alph_dec->height_; |
1583 | |
1584 | dec->status_ = VP8_STATUS_OK; |
1585 | VP8LInitBitReader(&dec->br_, data, data_size); |
1586 | |
1587 | if (!DecodeImageStream(alph_dec->width_, alph_dec->height_, 1, dec, NULL)) { |
1588 | goto Err; |
1589 | } |
1590 | |
1591 | // Special case: if alpha data uses only the color indexing transform and |
1592 | // doesn't use color cache (a frequent case), we will use DecodeAlphaData() |
1593 | // method that only needs allocation of 1 byte per pixel (alpha channel). |
1594 | if (dec->next_transform_ == 1 && |
1595 | dec->transforms_[0].type_ == COLOR_INDEXING_TRANSFORM && |
1596 | Is8bOptimizable(&dec->hdr_)) { |
1597 | alph_dec->use_8b_decode_ = 1; |
1598 | ok = AllocateInternalBuffers8b(dec); |
1599 | } else { |
1600 | // Allocate internal buffers (note that dec->width_ may have changed here). |
1601 | alph_dec->use_8b_decode_ = 0; |
1602 | ok = AllocateInternalBuffers32b(dec, alph_dec->width_); |
1603 | } |
1604 | |
1605 | if (!ok) goto Err; |
1606 | |
1607 | // Only set here, once we are sure it is valid (to avoid thread races). |
1608 | alph_dec->vp8l_dec_ = dec; |
1609 | return 1; |
1610 | |
1611 | Err: |
1612 | VP8LDelete(dec); |
1613 | return 0; |
1614 | } |
1615 | |
1616 | int VP8LDecodeAlphaImageStream(ALPHDecoder* const alph_dec, int last_row) { |
1617 | VP8LDecoder* const dec = alph_dec->vp8l_dec_; |
1618 | assert(dec != NULL); |
1619 | assert(last_row <= dec->height_); |
1620 | |
1621 | if (dec->last_row_ >= last_row) { |
1622 | return 1; // done |
1623 | } |
1624 | |
1625 | if (!alph_dec->use_8b_decode_) WebPInitAlphaProcessing(); |
1626 | |
1627 | // Decode (with special row processing). |
1628 | return alph_dec->use_8b_decode_ ? |
1629 | DecodeAlphaData(dec, (uint8_t*)dec->pixels_, dec->width_, dec->height_, |
1630 | last_row) : |
1631 | DecodeImageData(dec, dec->pixels_, dec->width_, dec->height_, |
1632 | last_row, ExtractAlphaRows); |
1633 | } |
1634 | |
1635 | //------------------------------------------------------------------------------ |
1636 | |
1637 | int (VP8LDecoder* const dec, VP8Io* const io) { |
1638 | int width, height, has_alpha; |
1639 | |
1640 | if (dec == NULL) return 0; |
1641 | if (io == NULL) { |
1642 | dec->status_ = VP8_STATUS_INVALID_PARAM; |
1643 | return 0; |
1644 | } |
1645 | |
1646 | dec->io_ = io; |
1647 | dec->status_ = VP8_STATUS_OK; |
1648 | VP8LInitBitReader(&dec->br_, io->data, io->data_size); |
1649 | if (!ReadImageInfo(&dec->br_, &width, &height, &has_alpha)) { |
1650 | dec->status_ = VP8_STATUS_BITSTREAM_ERROR; |
1651 | goto Error; |
1652 | } |
1653 | dec->state_ = READ_DIM; |
1654 | io->width = width; |
1655 | io->height = height; |
1656 | |
1657 | if (!DecodeImageStream(width, height, 1, dec, NULL)) goto Error; |
1658 | return 1; |
1659 | |
1660 | Error: |
1661 | VP8LClear(dec); |
1662 | assert(dec->status_ != VP8_STATUS_OK); |
1663 | return 0; |
1664 | } |
1665 | |
1666 | int VP8LDecodeImage(VP8LDecoder* const dec) { |
1667 | VP8Io* io = NULL; |
1668 | WebPDecParams* params = NULL; |
1669 | |
1670 | // Sanity checks. |
1671 | if (dec == NULL) return 0; |
1672 | |
1673 | assert(dec->hdr_.huffman_tables_ != NULL); |
1674 | assert(dec->hdr_.htree_groups_ != NULL); |
1675 | assert(dec->hdr_.num_htree_groups_ > 0); |
1676 | |
1677 | io = dec->io_; |
1678 | assert(io != NULL); |
1679 | params = (WebPDecParams*)io->opaque; |
1680 | assert(params != NULL); |
1681 | |
1682 | // Initialization. |
1683 | if (dec->state_ != READ_DATA) { |
1684 | dec->output_ = params->output; |
1685 | assert(dec->output_ != NULL); |
1686 | |
1687 | if (!WebPIoInitFromOptions(params->options, io, MODE_BGRA)) { |
1688 | dec->status_ = VP8_STATUS_INVALID_PARAM; |
1689 | goto Err; |
1690 | } |
1691 | |
1692 | if (!AllocateInternalBuffers32b(dec, io->width)) goto Err; |
1693 | |
1694 | #if !defined(WEBP_REDUCE_SIZE) |
1695 | if (io->use_scaling && !AllocateAndInitRescaler(dec, io)) goto Err; |
1696 | #else |
1697 | if (io->use_scaling) { |
1698 | dec->status_ = VP8_STATUS_INVALID_PARAM; |
1699 | goto Err; |
1700 | } |
1701 | #endif |
1702 | if (io->use_scaling || WebPIsPremultipliedMode(dec->output_->colorspace)) { |
1703 | // need the alpha-multiply functions for premultiplied output or rescaling |
1704 | WebPInitAlphaProcessing(); |
1705 | } |
1706 | |
1707 | if (!WebPIsRGBMode(dec->output_->colorspace)) { |
1708 | WebPInitConvertARGBToYUV(); |
1709 | if (dec->output_->u.YUVA.a != NULL) WebPInitAlphaProcessing(); |
1710 | } |
1711 | if (dec->incremental_) { |
1712 | if (dec->hdr_.color_cache_size_ > 0 && |
1713 | dec->hdr_.saved_color_cache_.colors_ == NULL) { |
1714 | if (!VP8LColorCacheInit(&dec->hdr_.saved_color_cache_, |
1715 | dec->hdr_.color_cache_.hash_bits_)) { |
1716 | dec->status_ = VP8_STATUS_OUT_OF_MEMORY; |
1717 | goto Err; |
1718 | } |
1719 | } |
1720 | } |
1721 | dec->state_ = READ_DATA; |
1722 | } |
1723 | |
1724 | // Decode. |
1725 | if (!DecodeImageData(dec, dec->pixels_, dec->width_, dec->height_, |
1726 | io->crop_bottom, ProcessRows)) { |
1727 | goto Err; |
1728 | } |
1729 | |
1730 | params->last_y = dec->last_out_row_; |
1731 | return 1; |
1732 | |
1733 | Err: |
1734 | VP8LClear(dec); |
1735 | assert(dec->status_ != VP8_STATUS_OK); |
1736 | return 0; |
1737 | } |
1738 | |
1739 | //------------------------------------------------------------------------------ |
1740 | |