Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * WebP (.webp) image decoder | ||
3 | * Copyright (c) 2013 Aneesh Dogra <aneesh@sugarlabs.org> | ||
4 | * Copyright (c) 2013 Justin Ruggles <justin.ruggles@gmail.com> | ||
5 | * | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | /** | ||
24 | * @file | ||
25 | * WebP image decoder | ||
26 | * | ||
27 | * @author Aneesh Dogra <aneesh@sugarlabs.org> | ||
28 | * Container and Lossy decoding | ||
29 | * | ||
30 | * @author Justin Ruggles <justin.ruggles@gmail.com> | ||
31 | * Lossless decoder | ||
32 | * Compressed alpha for lossy | ||
33 | * | ||
34 | * @author James Almer <jamrial@gmail.com> | ||
35 | * Exif metadata | ||
36 | * ICC profile | ||
37 | * | ||
38 | * Unimplemented: | ||
39 | * - Animation | ||
40 | * - XMP metadata | ||
41 | */ | ||
42 | |||
43 | #include "libavutil/imgutils.h" | ||
44 | #include "libavutil/mem.h" | ||
45 | |||
46 | #define BITSTREAM_READER_LE | ||
47 | #include "avcodec.h" | ||
48 | #include "bytestream.h" | ||
49 | #include "codec_internal.h" | ||
50 | #include "decode.h" | ||
51 | #include "exif.h" | ||
52 | #include "get_bits.h" | ||
53 | #include "thread.h" | ||
54 | #include "tiff_common.h" | ||
55 | #include "vp8.h" | ||
56 | |||
57 | #define VP8X_FLAG_ANIMATION 0x02 | ||
58 | #define VP8X_FLAG_XMP_METADATA 0x04 | ||
59 | #define VP8X_FLAG_EXIF_METADATA 0x08 | ||
60 | #define VP8X_FLAG_ALPHA 0x10 | ||
61 | #define VP8X_FLAG_ICC 0x20 | ||
62 | |||
63 | #define MAX_PALETTE_SIZE 256 | ||
64 | #define MAX_CACHE_BITS 11 | ||
65 | #define NUM_CODE_LENGTH_CODES 19 | ||
66 | #define HUFFMAN_CODES_PER_META_CODE 5 | ||
67 | #define NUM_LITERAL_CODES 256 | ||
68 | #define NUM_LENGTH_CODES 24 | ||
69 | #define NUM_DISTANCE_CODES 40 | ||
70 | #define NUM_SHORT_DISTANCES 120 | ||
71 | #define MAX_HUFFMAN_CODE_LENGTH 15 | ||
72 | |||
73 | static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE] = { | ||
74 | NUM_LITERAL_CODES + NUM_LENGTH_CODES, | ||
75 | NUM_LITERAL_CODES, NUM_LITERAL_CODES, NUM_LITERAL_CODES, | ||
76 | NUM_DISTANCE_CODES | ||
77 | }; | ||
78 | |||
79 | static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES] = { | ||
80 | 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 | ||
81 | }; | ||
82 | |||
83 | static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2] = { | ||
84 | { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 }, | ||
85 | { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 }, | ||
86 | { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 }, | ||
87 | { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 }, | ||
88 | { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 }, | ||
89 | { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 }, | ||
90 | { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 }, | ||
91 | { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 }, | ||
92 | { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 }, | ||
93 | { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 }, | ||
94 | { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 }, | ||
95 | { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 }, | ||
96 | { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 }, | ||
97 | { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 }, | ||
98 | { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 } | ||
99 | }; | ||
100 | |||
101 | enum AlphaCompression { | ||
102 | ALPHA_COMPRESSION_NONE, | ||
103 | ALPHA_COMPRESSION_VP8L, | ||
104 | }; | ||
105 | |||
106 | enum AlphaFilter { | ||
107 | ALPHA_FILTER_NONE, | ||
108 | ALPHA_FILTER_HORIZONTAL, | ||
109 | ALPHA_FILTER_VERTICAL, | ||
110 | ALPHA_FILTER_GRADIENT, | ||
111 | }; | ||
112 | |||
113 | enum TransformType { | ||
114 | PREDICTOR_TRANSFORM = 0, | ||
115 | COLOR_TRANSFORM = 1, | ||
116 | SUBTRACT_GREEN = 2, | ||
117 | COLOR_INDEXING_TRANSFORM = 3, | ||
118 | }; | ||
119 | |||
120 | enum PredictionMode { | ||
121 | PRED_MODE_BLACK, | ||
122 | PRED_MODE_L, | ||
123 | PRED_MODE_T, | ||
124 | PRED_MODE_TR, | ||
125 | PRED_MODE_TL, | ||
126 | PRED_MODE_AVG_T_AVG_L_TR, | ||
127 | PRED_MODE_AVG_L_TL, | ||
128 | PRED_MODE_AVG_L_T, | ||
129 | PRED_MODE_AVG_TL_T, | ||
130 | PRED_MODE_AVG_T_TR, | ||
131 | PRED_MODE_AVG_AVG_L_TL_AVG_T_TR, | ||
132 | PRED_MODE_SELECT, | ||
133 | PRED_MODE_ADD_SUBTRACT_FULL, | ||
134 | PRED_MODE_ADD_SUBTRACT_HALF, | ||
135 | }; | ||
136 | |||
137 | enum HuffmanIndex { | ||
138 | HUFF_IDX_GREEN = 0, | ||
139 | HUFF_IDX_RED = 1, | ||
140 | HUFF_IDX_BLUE = 2, | ||
141 | HUFF_IDX_ALPHA = 3, | ||
142 | HUFF_IDX_DIST = 4 | ||
143 | }; | ||
144 | |||
145 | /* The structure of WebP lossless is an optional series of transformation data, | ||
146 | * followed by the primary image. The primary image also optionally contains | ||
147 | * an entropy group mapping if there are multiple entropy groups. There is a | ||
148 | * basic image type called an "entropy coded image" that is used for all of | ||
149 | * these. The type of each entropy coded image is referred to by the | ||
150 | * specification as its role. */ | ||
151 | enum ImageRole { | ||
152 | /* Primary Image: Stores the actual pixels of the image. */ | ||
153 | IMAGE_ROLE_ARGB, | ||
154 | |||
155 | /* Entropy Image: Defines which Huffman group to use for different areas of | ||
156 | * the primary image. */ | ||
157 | IMAGE_ROLE_ENTROPY, | ||
158 | |||
159 | /* Predictors: Defines which predictor type to use for different areas of | ||
160 | * the primary image. */ | ||
161 | IMAGE_ROLE_PREDICTOR, | ||
162 | |||
163 | /* Color Transform Data: Defines the color transformation for different | ||
164 | * areas of the primary image. */ | ||
165 | IMAGE_ROLE_COLOR_TRANSFORM, | ||
166 | |||
167 | /* Color Index: Stored as an image of height == 1. */ | ||
168 | IMAGE_ROLE_COLOR_INDEXING, | ||
169 | |||
170 | IMAGE_ROLE_NB, | ||
171 | }; | ||
172 | |||
173 | typedef struct HuffReader { | ||
174 | VLC vlc; /* Huffman decoder context */ | ||
175 | int simple; /* whether to use simple mode */ | ||
176 | int nb_symbols; /* number of coded symbols */ | ||
177 | uint16_t simple_symbols[2]; /* symbols for simple mode */ | ||
178 | } HuffReader; | ||
179 | |||
180 | typedef struct ImageContext { | ||
181 | enum ImageRole role; /* role of this image */ | ||
182 | AVFrame *frame; /* AVFrame for data */ | ||
183 | int color_cache_bits; /* color cache size, log2 */ | ||
184 | uint32_t *color_cache; /* color cache data */ | ||
185 | int nb_huffman_groups; /* number of huffman groups */ | ||
186 | HuffReader *huffman_groups; /* reader for each huffman group */ | ||
187 | /* relative size compared to primary image, log2. | ||
188 | * for IMAGE_ROLE_COLOR_INDEXING with <= 16 colors, this is log2 of the | ||
189 | * number of pixels per byte in the primary image (pixel packing) */ | ||
190 | int size_reduction; | ||
191 | int is_alpha_primary; | ||
192 | } ImageContext; | ||
193 | |||
194 | typedef struct WebPContext { | ||
195 | VP8Context v; /* VP8 Context used for lossy decoding */ | ||
196 | GetBitContext gb; /* bitstream reader for main image chunk */ | ||
197 | AVFrame *alpha_frame; /* AVFrame for alpha data decompressed from VP8L */ | ||
198 | AVPacket *pkt; /* AVPacket to be passed to the underlying VP8 decoder */ | ||
199 | AVCodecContext *avctx; /* parent AVCodecContext */ | ||
200 | int initialized; /* set once the VP8 context is initialized */ | ||
201 | int has_alpha; /* has a separate alpha chunk */ | ||
202 | enum AlphaCompression alpha_compression; /* compression type for alpha chunk */ | ||
203 | enum AlphaFilter alpha_filter; /* filtering method for alpha chunk */ | ||
204 | const uint8_t *alpha_data; /* alpha chunk data */ | ||
205 | int alpha_data_size; /* alpha chunk data size */ | ||
206 | int has_exif; /* set after an EXIF chunk has been processed */ | ||
207 | int has_iccp; /* set after an ICCP chunk has been processed */ | ||
208 | int width; /* image width */ | ||
209 | int height; /* image height */ | ||
210 | int lossless; /* indicates lossless or lossy */ | ||
211 | |||
212 | int nb_transforms; /* number of transforms */ | ||
213 | enum TransformType transforms[4]; /* transformations used in the image, in order */ | ||
214 | /* reduced width when using a color indexing transform with <= 16 colors (pixel packing) | ||
215 | * before pixels are unpacked, or same as width otherwise. */ | ||
216 | int reduced_width; | ||
217 | int nb_huffman_groups; /* number of huffman groups in the primary image */ | ||
218 | ImageContext image[IMAGE_ROLE_NB]; /* image context for each role */ | ||
219 | } WebPContext; | ||
220 | |||
221 | #define GET_PIXEL(frame, x, y) \ | ||
222 | ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x)) | ||
223 | |||
224 | #define GET_PIXEL_COMP(frame, x, y, c) \ | ||
225 | (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c)) | ||
226 | |||
227 | 60 | static void image_ctx_free(ImageContext *img) | |
228 | { | ||
229 | int i, j; | ||
230 | |||
231 | 60 | av_free(img->color_cache); | |
232 |
3/4✓ Branch 0 taken 22 times.
✓ Branch 1 taken 38 times.
✓ Branch 2 taken 22 times.
✗ Branch 3 not taken.
|
60 | if (img->role != IMAGE_ROLE_ARGB && !img->is_alpha_primary) |
233 | 22 | av_frame_free(&img->frame); | |
234 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 26 times.
|
60 | if (img->huffman_groups) { |
235 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 34 times.
|
76 | for (i = 0; i < img->nb_huffman_groups; i++) { |
236 |
2/2✓ Branch 0 taken 210 times.
✓ Branch 1 taken 42 times.
|
252 | for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) |
237 | 210 | ff_vlc_free(&img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE + j].vlc); | |
238 | } | ||
239 | 34 | av_free(img->huffman_groups); | |
240 | } | ||
241 | 60 | memset(img, 0, sizeof(*img)); | |
242 | 60 | } | |
243 | |||
244 | 280428 | static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb) | |
245 | { | ||
246 |
2/2✓ Branch 0 taken 73834 times.
✓ Branch 1 taken 206594 times.
|
280428 | if (r->simple) { |
247 |
2/2✓ Branch 0 taken 73514 times.
✓ Branch 1 taken 320 times.
|
73834 | if (r->nb_symbols == 1) |
248 | 73514 | return r->simple_symbols[0]; | |
249 | else | ||
250 | 320 | return r->simple_symbols[get_bits1(gb)]; | |
251 | } else | ||
252 | 206594 | return get_vlc2(gb, r->vlc.table, 8, 2); | |
253 | } | ||
254 | |||
255 | 160 | static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths, | |
256 | uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH + 1], | ||
257 | uint8_t lens[], uint16_t syms[], | ||
258 | int alphabet_size, void *logctx) | ||
259 | { | ||
260 | 160 | unsigned nb_codes = 0; | |
261 | int ret; | ||
262 | |||
263 | // Count the number of symbols of each length and transform len_counts | ||
264 | // into an array of offsets. | ||
265 |
2/2✓ Branch 0 taken 2400 times.
✓ Branch 1 taken 160 times.
|
2560 | for (int len = 1; len <= MAX_HUFFMAN_CODE_LENGTH; ++len) { |
266 | 2400 | unsigned cnt = len_counts[len]; | |
267 | 2400 | len_counts[len] = nb_codes; | |
268 | 2400 | nb_codes += cnt; | |
269 | } | ||
270 | |||
271 |
2/2✓ Branch 0 taken 22050 times.
✓ Branch 1 taken 160 times.
|
22210 | for (int sym = 0; sym < alphabet_size; ++sym) { |
272 |
2/2✓ Branch 0 taken 7476 times.
✓ Branch 1 taken 14574 times.
|
22050 | if (code_lengths[sym]) { |
273 | 7476 | unsigned idx = len_counts[code_lengths[sym]]++; | |
274 | 7476 | syms[idx] = sym; | |
275 | 7476 | lens[idx] = code_lengths[sym]; | |
276 | } | ||
277 | } | ||
278 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 160 times.
|
160 | if (nb_codes <= 1) { |
279 | ✗ | if (nb_codes == 1) { | |
280 | /* special-case 1 symbol since the vlc reader cannot handle it */ | ||
281 | ✗ | r->nb_symbols = 1; | |
282 | ✗ | r->simple = 1; | |
283 | ✗ | r->simple_symbols[0] = syms[0]; | |
284 | } | ||
285 | // No symbols | ||
286 | ✗ | return AVERROR_INVALIDDATA; | |
287 | } | ||
288 | 160 | ret = ff_vlc_init_from_lengths(&r->vlc, 8, nb_codes, lens, 1, | |
289 | syms, 2, 2, 0, VLC_INIT_OUTPUT_LE, logctx); | ||
290 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 160 times.
|
160 | if (ret < 0) |
291 | ✗ | return ret; | |
292 | 160 | r->simple = 0; | |
293 | |||
294 | 160 | return 0; | |
295 | } | ||
296 | |||
297 | 130 | static void read_huffman_code_simple(WebPContext *s, HuffReader *hc) | |
298 | { | ||
299 | 130 | hc->nb_symbols = get_bits1(&s->gb) + 1; | |
300 | |||
301 |
2/2✓ Branch 1 taken 18 times.
✓ Branch 2 taken 112 times.
|
130 | if (get_bits1(&s->gb)) |
302 | 18 | hc->simple_symbols[0] = get_bits(&s->gb, 8); | |
303 | else | ||
304 | 112 | hc->simple_symbols[0] = get_bits1(&s->gb); | |
305 | |||
306 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 116 times.
|
130 | if (hc->nb_symbols == 2) |
307 | 14 | hc->simple_symbols[1] = get_bits(&s->gb, 8); | |
308 | |||
309 | 130 | hc->simple = 1; | |
310 | 130 | } | |
311 | |||
312 | 80 | static int read_huffman_code_normal(WebPContext *s, HuffReader *hc, | |
313 | int alphabet_size) | ||
314 | { | ||
315 | 80 | HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } }; | |
316 | uint8_t *code_lengths; | ||
317 | 80 | uint8_t code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 }; | |
318 | uint8_t reordered_code_length_code_lengths[NUM_CODE_LENGTH_CODES]; | ||
319 | uint16_t reordered_code_length_syms[NUM_CODE_LENGTH_CODES]; | ||
320 | 80 | uint16_t len_counts[MAX_HUFFMAN_CODE_LENGTH + 1] = { 0 }; | |
321 | int symbol, max_symbol, prev_code_len, ret; | ||
322 | 80 | int num_codes = 4 + get_bits(&s->gb, 4); | |
323 | |||
324 | av_assert1(num_codes <= NUM_CODE_LENGTH_CODES); | ||
325 | |||
326 |
2/2✓ Branch 0 taken 1100 times.
✓ Branch 1 taken 80 times.
|
1180 | for (int i = 0; i < num_codes; i++) { |
327 | 1100 | unsigned len = get_bits(&s->gb, 3); | |
328 | 1100 | code_length_code_lengths[code_length_code_order[i]] = len; | |
329 | 1100 | len_counts[len]++; | |
330 | } | ||
331 | |||
332 |
2/2✓ Branch 1 taken 8 times.
✓ Branch 2 taken 72 times.
|
80 | if (get_bits1(&s->gb)) { |
333 | 8 | int bits = 2 + 2 * get_bits(&s->gb, 3); | |
334 | 8 | max_symbol = 2 + get_bits(&s->gb, bits); | |
335 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
|
8 | if (max_symbol > alphabet_size) { |
336 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n", | |
337 | max_symbol, alphabet_size); | ||
338 | ✗ | return AVERROR_INVALIDDATA; | |
339 | } | ||
340 | } else { | ||
341 | 72 | max_symbol = alphabet_size; | |
342 | } | ||
343 | |||
344 | 80 | ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths, len_counts, | |
345 | reordered_code_length_code_lengths, | ||
346 | reordered_code_length_syms, | ||
347 | 80 | NUM_CODE_LENGTH_CODES, s->avctx); | |
348 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
|
80 | if (ret < 0) |
349 | ✗ | return ret; | |
350 | |||
351 | 80 | code_lengths = av_malloc_array(alphabet_size, 2 * sizeof(uint8_t) + sizeof(uint16_t)); | |
352 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
|
80 | if (!code_lengths) { |
353 | ✗ | ret = AVERROR(ENOMEM); | |
354 | ✗ | goto finish; | |
355 | } | ||
356 | |||
357 | 80 | prev_code_len = 8; | |
358 | 80 | symbol = 0; | |
359 | 80 | memset(len_counts, 0, sizeof(len_counts)); | |
360 |
2/2✓ Branch 0 taken 3264 times.
✓ Branch 1 taken 72 times.
|
3336 | while (symbol < alphabet_size) { |
361 | int code_len; | ||
362 | |||
363 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 3256 times.
|
3264 | if (!max_symbol--) |
364 | 8 | break; | |
365 | 3256 | code_len = huff_reader_get_symbol(&code_len_hc, &s->gb); | |
366 |
2/2✓ Branch 0 taken 1938 times.
✓ Branch 1 taken 1318 times.
|
3256 | if (code_len < 16U) { |
367 | /* Code length code [0..15] indicates literal code lengths. */ | ||
368 | 1938 | code_lengths[symbol++] = code_len; | |
369 | 1938 | len_counts[code_len]++; | |
370 |
2/2✓ Branch 0 taken 1818 times.
✓ Branch 1 taken 120 times.
|
1938 | if (code_len) |
371 | 1818 | prev_code_len = code_len; | |
372 | } else { | ||
373 | 1318 | int repeat = 0, length = 0; | |
374 |
3/4✗ Branch 0 not taken.
✓ Branch 1 taken 888 times.
✓ Branch 2 taken 160 times.
✓ Branch 3 taken 270 times.
|
1318 | switch (code_len) { |
375 | ✗ | default: | |
376 | ✗ | ret = AVERROR_INVALIDDATA; | |
377 | ✗ | goto finish; | |
378 | 888 | case 16: | |
379 | /* Code 16 repeats the previous non-zero value [3..6] times, | ||
380 | * i.e., 3 + ReadBits(2) times. If code 16 is used before a | ||
381 | * non-zero value has been emitted, a value of 8 is repeated. */ | ||
382 | 888 | repeat = 3 + get_bits(&s->gb, 2); | |
383 | 888 | length = prev_code_len; | |
384 | 888 | len_counts[length] += repeat; | |
385 | 888 | break; | |
386 | 160 | case 17: | |
387 | /* Code 17 emits a streak of zeros [3..10], i.e., | ||
388 | * 3 + ReadBits(3) times. */ | ||
389 | 160 | repeat = 3 + get_bits(&s->gb, 3); | |
390 | 160 | break; | |
391 | 270 | case 18: | |
392 | /* Code 18 emits a streak of zeros of length [11..138], i.e., | ||
393 | * 11 + ReadBits(7) times. */ | ||
394 | 270 | repeat = 11 + get_bits(&s->gb, 7); | |
395 | 270 | break; | |
396 | } | ||
397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1318 times.
|
1318 | if (symbol + repeat > alphabet_size) { |
398 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
399 | "invalid symbol %d + repeat %d > alphabet size %d\n", | ||
400 | symbol, repeat, alphabet_size); | ||
401 | ✗ | ret = AVERROR_INVALIDDATA; | |
402 | ✗ | goto finish; | |
403 | } | ||
404 |
2/2✓ Branch 0 taken 18592 times.
✓ Branch 1 taken 1318 times.
|
19910 | while (repeat-- > 0) |
405 | 18592 | code_lengths[symbol++] = length; | |
406 | } | ||
407 | } | ||
408 | |||
409 | 80 | ret = huff_reader_build_canonical(hc, code_lengths, len_counts, | |
410 | code_lengths + symbol, | ||
411 | 80 | (uint16_t*)(code_lengths + 2 * symbol), | |
412 | 80 | symbol, s->avctx); | |
413 | |||
414 | 80 | finish: | |
415 | 80 | ff_vlc_free(&code_len_hc.vlc); | |
416 | 80 | av_free(code_lengths); | |
417 | 80 | return ret; | |
418 | } | ||
419 | |||
420 | static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, | ||
421 | int w, int h); | ||
422 | |||
423 | #define PARSE_BLOCK_SIZE(w, h) do { \ | ||
424 | block_bits = get_bits(&s->gb, 3) + 2; \ | ||
425 | blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \ | ||
426 | blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \ | ||
427 | } while (0) | ||
428 | |||
429 | 4 | static int decode_entropy_image(WebPContext *s) | |
430 | { | ||
431 | ImageContext *img; | ||
432 | int ret, block_bits, blocks_w, blocks_h, x, y, max; | ||
433 | |||
434 | 4 | PARSE_BLOCK_SIZE(s->reduced_width, s->height); | |
435 | |||
436 | 4 | ret = decode_entropy_coded_image(s, IMAGE_ROLE_ENTROPY, blocks_w, blocks_h); | |
437 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
438 | ✗ | return ret; | |
439 | |||
440 | 4 | img = &s->image[IMAGE_ROLE_ENTROPY]; | |
441 | 4 | img->size_reduction = block_bits; | |
442 | |||
443 | /* the number of huffman groups is determined by the maximum group number | ||
444 | * coded in the entropy image */ | ||
445 | 4 | max = 0; | |
446 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 4 times.
|
68 | for (y = 0; y < img->frame->height; y++) { |
447 |
2/2✓ Branch 0 taken 1024 times.
✓ Branch 1 taken 64 times.
|
1088 | for (x = 0; x < img->frame->width; x++) { |
448 | 1024 | int p0 = GET_PIXEL_COMP(img->frame, x, y, 1); | |
449 | 1024 | int p1 = GET_PIXEL_COMP(img->frame, x, y, 2); | |
450 | 1024 | int p = p0 << 8 | p1; | |
451 | 1024 | max = FFMAX(max, p); | |
452 | } | ||
453 | } | ||
454 | 4 | s->nb_huffman_groups = max + 1; | |
455 | |||
456 | 4 | return 0; | |
457 | } | ||
458 | |||
459 | 6 | static int parse_transform_predictor(WebPContext *s) | |
460 | { | ||
461 | int block_bits, blocks_w, blocks_h, ret; | ||
462 | |||
463 | 6 | PARSE_BLOCK_SIZE(s->reduced_width, s->height); | |
464 | |||
465 | 6 | ret = decode_entropy_coded_image(s, IMAGE_ROLE_PREDICTOR, blocks_w, | |
466 | blocks_h); | ||
467 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
468 | ✗ | return ret; | |
469 | |||
470 | 6 | s->image[IMAGE_ROLE_PREDICTOR].size_reduction = block_bits; | |
471 | |||
472 | 6 | return 0; | |
473 | } | ||
474 | |||
475 | 4 | static int parse_transform_color(WebPContext *s) | |
476 | { | ||
477 | int block_bits, blocks_w, blocks_h, ret; | ||
478 | |||
479 | 4 | PARSE_BLOCK_SIZE(s->reduced_width, s->height); | |
480 | |||
481 | 4 | ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_TRANSFORM, blocks_w, | |
482 | blocks_h); | ||
483 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
484 | ✗ | return ret; | |
485 | |||
486 | 4 | s->image[IMAGE_ROLE_COLOR_TRANSFORM].size_reduction = block_bits; | |
487 | |||
488 | 4 | return 0; | |
489 | } | ||
490 | |||
491 | 8 | static int parse_transform_color_indexing(WebPContext *s) | |
492 | { | ||
493 | ImageContext *img; | ||
494 | int width_bits, index_size, ret, x; | ||
495 | uint8_t *ct; | ||
496 | |||
497 | 8 | index_size = get_bits(&s->gb, 8) + 1; | |
498 | |||
499 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
|
8 | if (index_size <= 2) |
500 | 2 | width_bits = 3; | |
501 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
|
6 | else if (index_size <= 4) |
502 | 2 | width_bits = 2; | |
503 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | else if (index_size <= 16) |
504 | ✗ | width_bits = 1; | |
505 | else | ||
506 | 4 | width_bits = 0; | |
507 | |||
508 | 8 | ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_INDEXING, | |
509 | index_size, 1); | ||
510 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
|
8 | if (ret < 0) |
511 | ✗ | return ret; | |
512 | |||
513 | 8 | img = &s->image[IMAGE_ROLE_COLOR_INDEXING]; | |
514 | 8 | img->size_reduction = width_bits; | |
515 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
|
8 | if (width_bits > 0) |
516 | 4 | s->reduced_width = (s->width + ((1 << width_bits) - 1)) >> width_bits; | |
517 | |||
518 | /* color index values are delta-coded */ | ||
519 | 8 | ct = img->frame->data[0] + 4; | |
520 |
2/2✓ Branch 0 taken 1424 times.
✓ Branch 1 taken 8 times.
|
1432 | for (x = 4; x < img->frame->width * 4; x++, ct++) |
521 | 1424 | ct[0] += ct[-4]; | |
522 | |||
523 | 8 | return 0; | |
524 | } | ||
525 | |||
526 | 69356 | static HuffReader *get_huffman_group(WebPContext *s, ImageContext *img, | |
527 | int x, int y) | ||
528 | { | ||
529 | 69356 | ImageContext *gimg = &s->image[IMAGE_ROLE_ENTROPY]; | |
530 | 69356 | int group = 0; | |
531 | |||
532 |
2/2✓ Branch 0 taken 65536 times.
✓ Branch 1 taken 3820 times.
|
69356 | if (gimg->size_reduction > 0) { |
533 | 65536 | int group_x = x >> gimg->size_reduction; | |
534 | 65536 | int group_y = y >> gimg->size_reduction; | |
535 | 65536 | int g0 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 1); | |
536 | 65536 | int g1 = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 2); | |
537 | 65536 | group = g0 << 8 | g1; | |
538 | } | ||
539 | |||
540 | 69356 | return &img->huffman_groups[group * HUFFMAN_CODES_PER_META_CODE]; | |
541 | } | ||
542 | |||
543 | ✗ | static av_always_inline void color_cache_put(ImageContext *img, uint32_t c) | |
544 | { | ||
545 | ✗ | uint32_t cache_idx = (0x1E35A7BD * c) >> (32 - img->color_cache_bits); | |
546 | ✗ | img->color_cache[cache_idx] = c; | |
547 | ✗ | } | |
548 | |||
549 | 34 | static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role, | |
550 | int w, int h) | ||
551 | { | ||
552 | ImageContext *img; | ||
553 | HuffReader *hg; | ||
554 | int i, j, ret, x, y, width; | ||
555 | |||
556 | 34 | img = &s->image[role]; | |
557 | 34 | img->role = role; | |
558 | |||
559 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 12 times.
|
34 | if (!img->frame) { |
560 | 22 | img->frame = av_frame_alloc(); | |
561 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (!img->frame) |
562 | ✗ | return AVERROR(ENOMEM); | |
563 | } | ||
564 | |||
565 | 34 | img->frame->format = AV_PIX_FMT_ARGB; | |
566 | 34 | img->frame->width = w; | |
567 | 34 | img->frame->height = h; | |
568 | |||
569 |
4/4✓ Branch 0 taken 12 times.
✓ Branch 1 taken 22 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 2 times.
|
34 | if (role == IMAGE_ROLE_ARGB && !img->is_alpha_primary) { |
570 | 10 | ret = ff_thread_get_buffer(s->avctx, img->frame, 0); | |
571 | } else | ||
572 | 24 | ret = av_frame_get_buffer(img->frame, 1); | |
573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (ret < 0) |
574 | ✗ | return ret; | |
575 | |||
576 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.
|
34 | if (get_bits1(&s->gb)) { |
577 | ✗ | img->color_cache_bits = get_bits(&s->gb, 4); | |
578 | ✗ | if (img->color_cache_bits < 1 || img->color_cache_bits > 11) { | |
579 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n", | |
580 | img->color_cache_bits); | ||
581 | ✗ | return AVERROR_INVALIDDATA; | |
582 | } | ||
583 | ✗ | img->color_cache = av_calloc(1 << img->color_cache_bits, | |
584 | sizeof(*img->color_cache)); | ||
585 | ✗ | if (!img->color_cache) | |
586 | ✗ | return AVERROR(ENOMEM); | |
587 | } else { | ||
588 | 34 | img->color_cache_bits = 0; | |
589 | } | ||
590 | |||
591 | 34 | img->nb_huffman_groups = 1; | |
592 |
4/4✓ Branch 0 taken 12 times.
✓ Branch 1 taken 22 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 8 times.
|
34 | if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) { |
593 | 4 | ret = decode_entropy_image(s); | |
594 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
595 | ✗ | return ret; | |
596 | 4 | img->nb_huffman_groups = s->nb_huffman_groups; | |
597 | } | ||
598 | 34 | img->huffman_groups = av_calloc(img->nb_huffman_groups, | |
599 | HUFFMAN_CODES_PER_META_CODE * | ||
600 | sizeof(*img->huffman_groups)); | ||
601 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 34 times.
|
34 | if (!img->huffman_groups) |
602 | ✗ | return AVERROR(ENOMEM); | |
603 | |||
604 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 34 times.
|
76 | for (i = 0; i < img->nb_huffman_groups; i++) { |
605 | 42 | hg = &img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE]; | |
606 |
2/2✓ Branch 0 taken 210 times.
✓ Branch 1 taken 42 times.
|
252 | for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) { |
607 | 210 | int alphabet_size = alphabet_sizes[j]; | |
608 |
3/4✓ Branch 0 taken 42 times.
✓ Branch 1 taken 168 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 42 times.
|
210 | if (!j && img->color_cache_bits > 0) |
609 | ✗ | alphabet_size += 1 << img->color_cache_bits; | |
610 | |||
611 |
2/2✓ Branch 1 taken 130 times.
✓ Branch 2 taken 80 times.
|
210 | if (get_bits1(&s->gb)) { |
612 | 130 | read_huffman_code_simple(s, &hg[j]); | |
613 | } else { | ||
614 | 80 | ret = read_huffman_code_normal(s, &hg[j], alphabet_size); | |
615 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 80 times.
|
80 | if (ret < 0) |
616 | ✗ | return ret; | |
617 | } | ||
618 | } | ||
619 | } | ||
620 | |||
621 | 34 | width = img->frame->width; | |
622 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 22 times.
|
34 | if (role == IMAGE_ROLE_ARGB) |
623 | 12 | width = s->reduced_width; | |
624 | |||
625 | 34 | x = 0; y = 0; | |
626 |
2/2✓ Branch 0 taken 69356 times.
✓ Branch 1 taken 34 times.
|
69390 | while (y < img->frame->height) { |
627 | int v; | ||
628 | |||
629 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 69356 times.
|
69356 | if (get_bits_left(&s->gb) < 0) |
630 | ✗ | return AVERROR_INVALIDDATA; | |
631 | |||
632 | 69356 | hg = get_huffman_group(s, img, x, y); | |
633 | 69356 | v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb); | |
634 |
2/2✓ Branch 0 taken 69230 times.
✓ Branch 1 taken 126 times.
|
69356 | if (v < NUM_LITERAL_CODES) { |
635 | /* literal pixel values */ | ||
636 | 69230 | uint8_t *p = GET_PIXEL(img->frame, x, y); | |
637 | 69230 | p[2] = v; | |
638 | 69230 | p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED], &s->gb); | |
639 | 69230 | p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE], &s->gb); | |
640 | 69230 | p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb); | |
641 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69230 times.
|
69230 | if (img->color_cache_bits) |
642 | ✗ | color_cache_put(img, AV_RB32(p)); | |
643 | 69230 | x++; | |
644 |
2/2✓ Branch 0 taken 750 times.
✓ Branch 1 taken 68480 times.
|
69230 | if (x == width) { |
645 | 750 | x = 0; | |
646 | 750 | y++; | |
647 | } | ||
648 |
1/2✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
|
126 | } else if (v < NUM_LITERAL_CODES + NUM_LENGTH_CODES) { |
649 | /* LZ77 backwards mapping */ | ||
650 | int prefix_code, length, distance, ref_x, ref_y; | ||
651 | |||
652 | /* parse length and distance */ | ||
653 | 126 | prefix_code = v - NUM_LITERAL_CODES; | |
654 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 78 times.
|
126 | if (prefix_code < 4) { |
655 | 48 | length = prefix_code + 1; | |
656 | } else { | ||
657 | 78 | int extra_bits = (prefix_code - 2) >> 1; | |
658 | 78 | int offset = 2 + (prefix_code & 1) << extra_bits; | |
659 | 78 | length = offset + get_bits(&s->gb, extra_bits) + 1; | |
660 | } | ||
661 | 126 | prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb); | |
662 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 126 times.
|
126 | if (prefix_code > 39U) { |
663 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
664 | "distance prefix code too large: %d\n", prefix_code); | ||
665 | ✗ | return AVERROR_INVALIDDATA; | |
666 | } | ||
667 |
1/2✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
|
126 | if (prefix_code < 4) { |
668 | 126 | distance = prefix_code + 1; | |
669 | } else { | ||
670 | ✗ | int extra_bits = prefix_code - 2 >> 1; | |
671 | ✗ | int offset = 2 + (prefix_code & 1) << extra_bits; | |
672 | ✗ | distance = offset + get_bits(&s->gb, extra_bits) + 1; | |
673 | } | ||
674 | |||
675 | /* find reference location */ | ||
676 |
1/2✓ Branch 0 taken 126 times.
✗ Branch 1 not taken.
|
126 | if (distance <= NUM_SHORT_DISTANCES) { |
677 | 126 | int xi = lz77_distance_offsets[distance - 1][0]; | |
678 | 126 | int yi = lz77_distance_offsets[distance - 1][1]; | |
679 | 126 | distance = FFMAX(1, xi + yi * width); | |
680 | } else { | ||
681 | ✗ | distance -= NUM_SHORT_DISTANCES; | |
682 | } | ||
683 | 126 | ref_x = x; | |
684 | 126 | ref_y = y; | |
685 |
2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 86 times.
|
126 | if (distance <= x) { |
686 | 40 | ref_x -= distance; | |
687 | 40 | distance = 0; | |
688 | } else { | ||
689 | 86 | ref_x = 0; | |
690 | 86 | distance -= x; | |
691 | } | ||
692 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 126 times.
|
148 | while (distance >= width) { |
693 | 22 | ref_y--; | |
694 | 22 | distance -= width; | |
695 | } | ||
696 |
2/2✓ Branch 0 taken 64 times.
✓ Branch 1 taken 62 times.
|
126 | if (distance > 0) { |
697 | 64 | ref_x = width - distance; | |
698 | 64 | ref_y--; | |
699 | } | ||
700 | 126 | ref_x = FFMAX(0, ref_x); | |
701 | 126 | ref_y = FFMAX(0, ref_y); | |
702 | |||
703 |
3/4✓ Branch 0 taken 40 times.
✓ Branch 1 taken 86 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 40 times.
|
126 | if (ref_y == y && ref_x >= x) |
704 | ✗ | return AVERROR_INVALIDDATA; | |
705 | |||
706 | /* copy pixels | ||
707 | * source and dest regions can overlap and wrap lines, so just | ||
708 | * copy per-pixel */ | ||
709 |
2/2✓ Branch 0 taken 958 times.
✓ Branch 1 taken 118 times.
|
1076 | for (i = 0; i < length; i++) { |
710 | 958 | uint8_t *p_ref = GET_PIXEL(img->frame, ref_x, ref_y); | |
711 | 958 | uint8_t *p = GET_PIXEL(img->frame, x, y); | |
712 | |||
713 | 958 | AV_COPY32(p, p_ref); | |
714 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 958 times.
|
958 | if (img->color_cache_bits) |
715 | ✗ | color_cache_put(img, AV_RB32(p)); | |
716 | 958 | x++; | |
717 | 958 | ref_x++; | |
718 |
2/2✓ Branch 0 taken 74 times.
✓ Branch 1 taken 884 times.
|
958 | if (x == width) { |
719 | 74 | x = 0; | |
720 | 74 | y++; | |
721 | } | ||
722 |
2/2✓ Branch 0 taken 72 times.
✓ Branch 1 taken 886 times.
|
958 | if (ref_x == width) { |
723 | 72 | ref_x = 0; | |
724 | 72 | ref_y++; | |
725 | } | ||
726 |
3/4✓ Branch 0 taken 950 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 950 times.
✗ Branch 3 not taken.
|
958 | if (y == img->frame->height || ref_y == img->frame->height) |
727 | break; | ||
728 | } | ||
729 | } else { | ||
730 | /* read from color cache */ | ||
731 | ✗ | uint8_t *p = GET_PIXEL(img->frame, x, y); | |
732 | ✗ | int cache_idx = v - (NUM_LITERAL_CODES + NUM_LENGTH_CODES); | |
733 | |||
734 | ✗ | if (!img->color_cache_bits) { | |
735 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "color cache not found\n"); | |
736 | ✗ | return AVERROR_INVALIDDATA; | |
737 | } | ||
738 | ✗ | if (cache_idx >= 1 << img->color_cache_bits) { | |
739 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
740 | "color cache index out-of-bounds\n"); | ||
741 | ✗ | return AVERROR_INVALIDDATA; | |
742 | } | ||
743 | ✗ | AV_WB32(p, img->color_cache[cache_idx]); | |
744 | ✗ | x++; | |
745 | ✗ | if (x == width) { | |
746 | ✗ | x = 0; | |
747 | ✗ | y++; | |
748 | } | ||
749 | } | ||
750 | } | ||
751 | |||
752 | 34 | return 0; | |
753 | } | ||
754 | |||
755 | /* PRED_MODE_BLACK */ | ||
756 | 6 | static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
757 | const uint8_t *p_t, const uint8_t *p_tr) | ||
758 | { | ||
759 | 6 | AV_WB32(p, 0xFF000000); | |
760 | 6 | } | |
761 | |||
762 | /* PRED_MODE_L */ | ||
763 | 5300 | static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
764 | const uint8_t *p_t, const uint8_t *p_tr) | ||
765 | { | ||
766 | 5300 | AV_COPY32(p, p_l); | |
767 | 5300 | } | |
768 | |||
769 | /* PRED_MODE_T */ | ||
770 | 21182 | static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
771 | const uint8_t *p_t, const uint8_t *p_tr) | ||
772 | { | ||
773 | 21182 | AV_COPY32(p, p_t); | |
774 | 21182 | } | |
775 | |||
776 | /* PRED_MODE_TR */ | ||
777 | 6336 | static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
778 | const uint8_t *p_t, const uint8_t *p_tr) | ||
779 | { | ||
780 | 6336 | AV_COPY32(p, p_tr); | |
781 | 6336 | } | |
782 | |||
783 | /* PRED_MODE_TL */ | ||
784 | 1248 | static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
785 | const uint8_t *p_t, const uint8_t *p_tr) | ||
786 | { | ||
787 | 1248 | AV_COPY32(p, p_tl); | |
788 | 1248 | } | |
789 | |||
790 | /* PRED_MODE_AVG_T_AVG_L_TR */ | ||
791 | 4832 | static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
792 | const uint8_t *p_t, const uint8_t *p_tr) | ||
793 | { | ||
794 | 4832 | p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1; | |
795 | 4832 | p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1; | |
796 | 4832 | p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1; | |
797 | 4832 | p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1; | |
798 | 4832 | } | |
799 | |||
800 | /* PRED_MODE_AVG_L_TL */ | ||
801 | 768 | static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
802 | const uint8_t *p_t, const uint8_t *p_tr) | ||
803 | { | ||
804 | 768 | p[0] = p_l[0] + p_tl[0] >> 1; | |
805 | 768 | p[1] = p_l[1] + p_tl[1] >> 1; | |
806 | 768 | p[2] = p_l[2] + p_tl[2] >> 1; | |
807 | 768 | p[3] = p_l[3] + p_tl[3] >> 1; | |
808 | 768 | } | |
809 | |||
810 | /* PRED_MODE_AVG_L_T */ | ||
811 | 3072 | static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
812 | const uint8_t *p_t, const uint8_t *p_tr) | ||
813 | { | ||
814 | 3072 | p[0] = p_l[0] + p_t[0] >> 1; | |
815 | 3072 | p[1] = p_l[1] + p_t[1] >> 1; | |
816 | 3072 | p[2] = p_l[2] + p_t[2] >> 1; | |
817 | 3072 | p[3] = p_l[3] + p_t[3] >> 1; | |
818 | 3072 | } | |
819 | |||
820 | /* PRED_MODE_AVG_TL_T */ | ||
821 | 4512 | static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
822 | const uint8_t *p_t, const uint8_t *p_tr) | ||
823 | { | ||
824 | 4512 | p[0] = p_tl[0] + p_t[0] >> 1; | |
825 | 4512 | p[1] = p_tl[1] + p_t[1] >> 1; | |
826 | 4512 | p[2] = p_tl[2] + p_t[2] >> 1; | |
827 | 4512 | p[3] = p_tl[3] + p_t[3] >> 1; | |
828 | 4512 | } | |
829 | |||
830 | /* PRED_MODE_AVG_T_TR */ | ||
831 | 11488 | static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
832 | const uint8_t *p_t, const uint8_t *p_tr) | ||
833 | { | ||
834 | 11488 | p[0] = p_t[0] + p_tr[0] >> 1; | |
835 | 11488 | p[1] = p_t[1] + p_tr[1] >> 1; | |
836 | 11488 | p[2] = p_t[2] + p_tr[2] >> 1; | |
837 | 11488 | p[3] = p_t[3] + p_tr[3] >> 1; | |
838 | 11488 | } | |
839 | |||
840 | /* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */ | ||
841 | 3236 | static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
842 | const uint8_t *p_t, const uint8_t *p_tr) | ||
843 | { | ||
844 | 3236 | p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1; | |
845 | 3236 | p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1; | |
846 | 3236 | p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1; | |
847 | 3236 | p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1; | |
848 | 3236 | } | |
849 | |||
850 | /* PRED_MODE_SELECT */ | ||
851 | 3824 | static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
852 | const uint8_t *p_t, const uint8_t *p_tr) | ||
853 | { | ||
854 | 3824 | int diff = (FFABS(p_l[0] - p_tl[0]) - FFABS(p_t[0] - p_tl[0])) + | |
855 | 3824 | (FFABS(p_l[1] - p_tl[1]) - FFABS(p_t[1] - p_tl[1])) + | |
856 | 3824 | (FFABS(p_l[2] - p_tl[2]) - FFABS(p_t[2] - p_tl[2])) + | |
857 | 3824 | (FFABS(p_l[3] - p_tl[3]) - FFABS(p_t[3] - p_tl[3])); | |
858 |
2/2✓ Branch 0 taken 2602 times.
✓ Branch 1 taken 1222 times.
|
3824 | if (diff <= 0) |
859 | 2602 | AV_COPY32(p, p_t); | |
860 | else | ||
861 | 1222 | AV_COPY32(p, p_l); | |
862 | 3824 | } | |
863 | |||
864 | /* PRED_MODE_ADD_SUBTRACT_FULL */ | ||
865 | ✗ | static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
866 | const uint8_t *p_t, const uint8_t *p_tr) | ||
867 | { | ||
868 | ✗ | p[0] = av_clip_uint8(p_l[0] + p_t[0] - p_tl[0]); | |
869 | ✗ | p[1] = av_clip_uint8(p_l[1] + p_t[1] - p_tl[1]); | |
870 | ✗ | p[2] = av_clip_uint8(p_l[2] + p_t[2] - p_tl[2]); | |
871 | ✗ | p[3] = av_clip_uint8(p_l[3] + p_t[3] - p_tl[3]); | |
872 | ✗ | } | |
873 | |||
874 | 2048 | static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c) | |
875 | { | ||
876 | 2048 | int d = a + b >> 1; | |
877 | 2048 | return av_clip_uint8(d + (d - c) / 2); | |
878 | } | ||
879 | |||
880 | /* PRED_MODE_ADD_SUBTRACT_HALF */ | ||
881 | 512 | static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl, | |
882 | const uint8_t *p_t, const uint8_t *p_tr) | ||
883 | { | ||
884 | 512 | p[0] = clamp_add_subtract_half(p_l[0], p_t[0], p_tl[0]); | |
885 | 512 | p[1] = clamp_add_subtract_half(p_l[1], p_t[1], p_tl[1]); | |
886 | 512 | p[2] = clamp_add_subtract_half(p_l[2], p_t[2], p_tl[2]); | |
887 | 512 | p[3] = clamp_add_subtract_half(p_l[3], p_t[3], p_tl[3]); | |
888 | 512 | } | |
889 | |||
890 | typedef void (*inv_predict_func)(uint8_t *p, const uint8_t *p_l, | ||
891 | const uint8_t *p_tl, const uint8_t *p_t, | ||
892 | const uint8_t *p_tr); | ||
893 | |||
894 | static const inv_predict_func inverse_predict[14] = { | ||
895 | inv_predict_0, inv_predict_1, inv_predict_2, inv_predict_3, | ||
896 | inv_predict_4, inv_predict_5, inv_predict_6, inv_predict_7, | ||
897 | inv_predict_8, inv_predict_9, inv_predict_10, inv_predict_11, | ||
898 | inv_predict_12, inv_predict_13, | ||
899 | }; | ||
900 | |||
901 | 66316 | static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y) | |
902 | { | ||
903 | uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr; | ||
904 | uint8_t p[4]; | ||
905 | |||
906 | 66316 | dec = GET_PIXEL(frame, x, y); | |
907 | 66316 | p_l = GET_PIXEL(frame, x - 1, y); | |
908 | 66316 | p_tl = GET_PIXEL(frame, x - 1, y - 1); | |
909 | 66316 | p_t = GET_PIXEL(frame, x, y - 1); | |
910 |
2/2✓ Branch 0 taken 512 times.
✓ Branch 1 taken 65804 times.
|
66316 | if (x == frame->width - 1) |
911 | 512 | p_tr = GET_PIXEL(frame, 0, y); | |
912 | else | ||
913 | 65804 | p_tr = GET_PIXEL(frame, x + 1, y - 1); | |
914 | |||
915 | 66316 | inverse_predict[m](p, p_l, p_tl, p_t, p_tr); | |
916 | |||
917 | 66316 | dec[0] += p[0]; | |
918 | 66316 | dec[1] += p[1]; | |
919 | 66316 | dec[2] += p[2]; | |
920 | 66316 | dec[3] += p[3]; | |
921 | 66316 | } | |
922 | |||
923 | 6 | static int apply_predictor_transform(WebPContext *s) | |
924 | { | ||
925 | 6 | ImageContext *img = &s->image[IMAGE_ROLE_ARGB]; | |
926 | 6 | ImageContext *pimg = &s->image[IMAGE_ROLE_PREDICTOR]; | |
927 | int x, y; | ||
928 | |||
929 |
2/2✓ Branch 0 taken 572 times.
✓ Branch 1 taken 6 times.
|
578 | for (y = 0; y < img->frame->height; y++) { |
930 |
2/2✓ Branch 0 taken 66316 times.
✓ Branch 1 taken 572 times.
|
66888 | for (x = 0; x < s->reduced_width; x++) { |
931 | 66316 | int tx = x >> pimg->size_reduction; | |
932 | 66316 | int ty = y >> pimg->size_reduction; | |
933 | 66316 | enum PredictionMode m = GET_PIXEL_COMP(pimg->frame, tx, ty, 2); | |
934 | |||
935 |
2/2✓ Branch 0 taken 572 times.
✓ Branch 1 taken 65744 times.
|
66316 | if (x == 0) { |
936 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 566 times.
|
572 | if (y == 0) |
937 | 6 | m = PRED_MODE_BLACK; | |
938 | else | ||
939 | 566 | m = PRED_MODE_T; | |
940 |
2/2✓ Branch 0 taken 532 times.
✓ Branch 1 taken 65212 times.
|
65744 | } else if (y == 0) |
941 | 532 | m = PRED_MODE_L; | |
942 | |||
943 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 66316 times.
|
66316 | if (m > 13) { |
944 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
945 | "invalid predictor mode: %d\n", m); | ||
946 | ✗ | return AVERROR_INVALIDDATA; | |
947 | } | ||
948 | 66316 | inverse_prediction(img->frame, m, x, y); | |
949 | } | ||
950 | } | ||
951 | 6 | return 0; | |
952 | } | ||
953 | |||
954 | 196608 | static av_always_inline uint8_t color_transform_delta(uint8_t color_pred, | |
955 | uint8_t color) | ||
956 | { | ||
957 | 196608 | return (int)ff_u8_to_s8(color_pred) * ff_u8_to_s8(color) >> 5; | |
958 | } | ||
959 | |||
960 | 4 | static int apply_color_transform(WebPContext *s) | |
961 | { | ||
962 | ImageContext *img, *cimg; | ||
963 | int x, y, cx, cy; | ||
964 | uint8_t *p, *cp; | ||
965 | |||
966 | 4 | img = &s->image[IMAGE_ROLE_ARGB]; | |
967 | 4 | cimg = &s->image[IMAGE_ROLE_COLOR_TRANSFORM]; | |
968 | |||
969 |
2/2✓ Branch 0 taken 512 times.
✓ Branch 1 taken 4 times.
|
516 | for (y = 0; y < img->frame->height; y++) { |
970 |
2/2✓ Branch 0 taken 65536 times.
✓ Branch 1 taken 512 times.
|
66048 | for (x = 0; x < s->reduced_width; x++) { |
971 | 65536 | cx = x >> cimg->size_reduction; | |
972 | 65536 | cy = y >> cimg->size_reduction; | |
973 | 65536 | cp = GET_PIXEL(cimg->frame, cx, cy); | |
974 | 65536 | p = GET_PIXEL(img->frame, x, y); | |
975 | |||
976 | 65536 | p[1] += color_transform_delta(cp[3], p[2]); | |
977 | 65536 | p[3] += color_transform_delta(cp[2], p[2]) + | |
978 | 65536 | color_transform_delta(cp[1], p[1]); | |
979 | } | ||
980 | } | ||
981 | 4 | return 0; | |
982 | } | ||
983 | |||
984 | 4 | static int apply_subtract_green_transform(WebPContext *s) | |
985 | { | ||
986 | int x, y; | ||
987 | 4 | ImageContext *img = &s->image[IMAGE_ROLE_ARGB]; | |
988 | |||
989 |
2/2✓ Branch 0 taken 512 times.
✓ Branch 1 taken 4 times.
|
516 | for (y = 0; y < img->frame->height; y++) { |
990 |
2/2✓ Branch 0 taken 65536 times.
✓ Branch 1 taken 512 times.
|
66048 | for (x = 0; x < s->reduced_width; x++) { |
991 | 65536 | uint8_t *p = GET_PIXEL(img->frame, x, y); | |
992 | 65536 | p[1] += p[2]; | |
993 | 65536 | p[3] += p[2]; | |
994 | } | ||
995 | } | ||
996 | 4 | return 0; | |
997 | } | ||
998 | |||
999 | 8 | static int apply_color_indexing_transform(WebPContext *s) | |
1000 | { | ||
1001 | ImageContext *img; | ||
1002 | ImageContext *pal; | ||
1003 | int i, x, y; | ||
1004 | uint8_t *p; | ||
1005 | |||
1006 | 8 | img = &s->image[IMAGE_ROLE_ARGB]; | |
1007 | 8 | pal = &s->image[IMAGE_ROLE_COLOR_INDEXING]; | |
1008 | |||
1009 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
|
8 | if (pal->size_reduction > 0) { // undo pixel packing |
1010 | GetBitContext gb_g; | ||
1011 | uint8_t *line; | ||
1012 | 4 | int pixel_bits = 8 >> pal->size_reduction; | |
1013 | |||
1014 | 4 | line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE); | |
1015 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (!line) |
1016 | ✗ | return AVERROR(ENOMEM); | |
1017 | |||
1018 |
2/2✓ Branch 0 taken 76 times.
✓ Branch 1 taken 4 times.
|
80 | for (y = 0; y < img->frame->height; y++) { |
1019 | 76 | p = GET_PIXEL(img->frame, 0, y); | |
1020 | 76 | memcpy(line, p, img->frame->linesize[0]); | |
1021 | 76 | init_get_bits(&gb_g, line, img->frame->linesize[0] * 8); | |
1022 | 76 | skip_bits(&gb_g, 16); | |
1023 | 76 | i = 0; | |
1024 |
2/2✓ Branch 0 taken 6192 times.
✓ Branch 1 taken 76 times.
|
6268 | for (x = 0; x < img->frame->width; x++) { |
1025 | 6192 | p = GET_PIXEL(img->frame, x, y); | |
1026 | 6192 | p[2] = get_bits(&gb_g, pixel_bits); | |
1027 | 6192 | i++; | |
1028 |
2/2✓ Branch 0 taken 768 times.
✓ Branch 1 taken 5424 times.
|
6192 | if (i == 1 << pal->size_reduction) { |
1029 | 768 | skip_bits(&gb_g, 24); | |
1030 | 768 | i = 0; | |
1031 | } | ||
1032 | } | ||
1033 | } | ||
1034 | 4 | av_free(line); | |
1035 | 4 | s->reduced_width = s->width; // we are back to full size | |
1036 | } | ||
1037 | |||
1038 | // switch to local palette if it's worth initializing it | ||
1039 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 6 times.
|
8 | if (img->frame->height * img->frame->width > 300) { |
1040 | uint8_t palette[256 * 4]; | ||
1041 | 2 | const int size = pal->frame->width * 4; | |
1042 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | av_assert0(size <= 1024U); |
1043 | 2 | memcpy(palette, GET_PIXEL(pal->frame, 0, 0), size); // copy palette | |
1044 | // set extra entries to transparent black | ||
1045 | 2 | memset(palette + size, 0, 256 * 4 - size); | |
1046 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 2 times.
|
62 | for (y = 0; y < img->frame->height; y++) { |
1047 |
2/2✓ Branch 0 taken 6000 times.
✓ Branch 1 taken 60 times.
|
6060 | for (x = 0; x < img->frame->width; x++) { |
1048 | 6000 | p = GET_PIXEL(img->frame, x, y); | |
1049 | 6000 | i = p[2]; | |
1050 | 6000 | AV_COPY32(p, &palette[i * 4]); | |
1051 | } | ||
1052 | } | ||
1053 | } else { | ||
1054 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 6 times.
|
54 | for (y = 0; y < img->frame->height; y++) { |
1055 |
2/2✓ Branch 0 taken 576 times.
✓ Branch 1 taken 48 times.
|
624 | for (x = 0; x < img->frame->width; x++) { |
1056 | 576 | p = GET_PIXEL(img->frame, x, y); | |
1057 | 576 | i = p[2]; | |
1058 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 576 times.
|
576 | if (i >= pal->frame->width) { |
1059 | ✗ | AV_WB32(p, 0x00000000); | |
1060 | } else { | ||
1061 | 576 | const uint8_t *pi = GET_PIXEL(pal->frame, i, 0); | |
1062 | 576 | AV_COPY32(p, pi); | |
1063 | } | ||
1064 | } | ||
1065 | } | ||
1066 | } | ||
1067 | |||
1068 | 8 | return 0; | |
1069 | } | ||
1070 | |||
1071 | 16 | static void update_canvas_size(AVCodecContext *avctx, int w, int h) | |
1072 | { | ||
1073 | 16 | WebPContext *s = avctx->priv_data; | |
1074 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
16 | if (s->width && s->width != w) { |
1075 | ✗ | av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n", | |
1076 | s->width, w); | ||
1077 | } | ||
1078 | 16 | s->width = w; | |
1079 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 12 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
16 | if (s->height && s->height != h) { |
1080 | ✗ | av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n", | |
1081 | s->height, h); | ||
1082 | } | ||
1083 | 16 | s->height = h; | |
1084 | 16 | } | |
1085 | |||
1086 | 12 | static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p, | |
1087 | int *got_frame, const uint8_t *data_start, | ||
1088 | unsigned int data_size, int is_alpha_chunk) | ||
1089 | { | ||
1090 | 12 | WebPContext *s = avctx->priv_data; | |
1091 | int w, h, ret, i, used; | ||
1092 | |||
1093 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 2 times.
|
12 | if (!is_alpha_chunk) { |
1094 | 10 | s->lossless = 1; | |
1095 | 10 | avctx->pix_fmt = AV_PIX_FMT_ARGB; | |
1096 | } | ||
1097 | |||
1098 | 12 | ret = init_get_bits8(&s->gb, data_start, data_size); | |
1099 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
1100 | ✗ | return ret; | |
1101 | |||
1102 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 2 times.
|
12 | if (!is_alpha_chunk) { |
1103 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
|
10 | if (get_bits(&s->gb, 8) != 0x2F) { |
1104 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n"); | |
1105 | ✗ | return AVERROR_INVALIDDATA; | |
1106 | } | ||
1107 | |||
1108 | 10 | w = get_bits(&s->gb, 14) + 1; | |
1109 | 10 | h = get_bits(&s->gb, 14) + 1; | |
1110 | |||
1111 | 10 | update_canvas_size(avctx, w, h); | |
1112 | |||
1113 | 10 | ret = ff_set_dimensions(avctx, s->width, s->height); | |
1114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (ret < 0) |
1115 | ✗ | return ret; | |
1116 | |||
1117 | 10 | s->has_alpha = get_bits1(&s->gb); | |
1118 | |||
1119 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 10 times.
|
10 | if (get_bits(&s->gb, 3) != 0x0) { |
1120 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n"); | |
1121 | ✗ | return AVERROR_INVALIDDATA; | |
1122 | } | ||
1123 | } else { | ||
1124 |
2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
2 | if (!s->width || !s->height) |
1125 | ✗ | return AVERROR_BUG; | |
1126 | 2 | w = s->width; | |
1127 | 2 | h = s->height; | |
1128 | } | ||
1129 | |||
1130 | /* parse transformations */ | ||
1131 | 12 | s->nb_transforms = 0; | |
1132 | 12 | s->reduced_width = s->width; | |
1133 | 12 | used = 0; | |
1134 |
2/2✓ Branch 1 taken 22 times.
✓ Branch 2 taken 12 times.
|
34 | while (get_bits1(&s->gb)) { |
1135 | 22 | enum TransformType transform = get_bits(&s->gb, 2); | |
1136 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (used & (1 << transform)) { |
1137 | ✗ | av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n", | |
1138 | transform); | ||
1139 | ✗ | ret = AVERROR_INVALIDDATA; | |
1140 | ✗ | goto free_and_return; | |
1141 | } | ||
1142 | 22 | used |= (1 << transform); | |
1143 | 22 | s->transforms[s->nb_transforms++] = transform; | |
1144 |
4/4✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 4 times.
|
22 | switch (transform) { |
1145 | 6 | case PREDICTOR_TRANSFORM: | |
1146 | 6 | ret = parse_transform_predictor(s); | |
1147 | 6 | break; | |
1148 | 4 | case COLOR_TRANSFORM: | |
1149 | 4 | ret = parse_transform_color(s); | |
1150 | 4 | break; | |
1151 | 8 | case COLOR_INDEXING_TRANSFORM: | |
1152 | 8 | ret = parse_transform_color_indexing(s); | |
1153 | 8 | break; | |
1154 | } | ||
1155 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (ret < 0) |
1156 | ✗ | goto free_and_return; | |
1157 | } | ||
1158 | |||
1159 | /* decode primary image */ | ||
1160 | 12 | s->image[IMAGE_ROLE_ARGB].frame = p; | |
1161 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 10 times.
|
12 | if (is_alpha_chunk) |
1162 | 2 | s->image[IMAGE_ROLE_ARGB].is_alpha_primary = 1; | |
1163 | 12 | ret = decode_entropy_coded_image(s, IMAGE_ROLE_ARGB, w, h); | |
1164 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (ret < 0) |
1165 | ✗ | goto free_and_return; | |
1166 | |||
1167 | /* apply transformations */ | ||
1168 |
2/2✓ Branch 0 taken 22 times.
✓ Branch 1 taken 12 times.
|
34 | for (i = s->nb_transforms - 1; i >= 0; i--) { |
1169 |
4/5✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 8 times.
✗ Branch 4 not taken.
|
22 | switch (s->transforms[i]) { |
1170 | 6 | case PREDICTOR_TRANSFORM: | |
1171 | 6 | ret = apply_predictor_transform(s); | |
1172 | 6 | break; | |
1173 | 4 | case COLOR_TRANSFORM: | |
1174 | 4 | ret = apply_color_transform(s); | |
1175 | 4 | break; | |
1176 | 4 | case SUBTRACT_GREEN: | |
1177 | 4 | ret = apply_subtract_green_transform(s); | |
1178 | 4 | break; | |
1179 | 8 | case COLOR_INDEXING_TRANSFORM: | |
1180 | 8 | ret = apply_color_indexing_transform(s); | |
1181 | 8 | break; | |
1182 | } | ||
1183 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
|
22 | if (ret < 0) |
1184 | ✗ | goto free_and_return; | |
1185 | } | ||
1186 | |||
1187 | 12 | *got_frame = 1; | |
1188 | 12 | p->pict_type = AV_PICTURE_TYPE_I; | |
1189 | 12 | p->flags |= AV_FRAME_FLAG_KEY; | |
1190 | 12 | p->flags |= AV_FRAME_FLAG_LOSSLESS; | |
1191 | 12 | ret = data_size; | |
1192 | |||
1193 | 12 | free_and_return: | |
1194 |
2/2✓ Branch 0 taken 60 times.
✓ Branch 1 taken 12 times.
|
72 | for (i = 0; i < IMAGE_ROLE_NB; i++) |
1195 | 60 | image_ctx_free(&s->image[i]); | |
1196 | |||
1197 | 12 | return ret; | |
1198 | } | ||
1199 | |||
1200 | ✗ | static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m) | |
1201 | { | ||
1202 | int x, y, ls; | ||
1203 | uint8_t *dec; | ||
1204 | |||
1205 | ✗ | ls = frame->linesize[3]; | |
1206 | |||
1207 | /* filter first row using horizontal filter */ | ||
1208 | ✗ | dec = frame->data[3] + 1; | |
1209 | ✗ | for (x = 1; x < frame->width; x++, dec++) | |
1210 | ✗ | *dec += *(dec - 1); | |
1211 | |||
1212 | /* filter first column using vertical filter */ | ||
1213 | ✗ | dec = frame->data[3] + ls; | |
1214 | ✗ | for (y = 1; y < frame->height; y++, dec += ls) | |
1215 | ✗ | *dec += *(dec - ls); | |
1216 | |||
1217 | /* filter the rest using the specified filter */ | ||
1218 | ✗ | switch (m) { | |
1219 | ✗ | case ALPHA_FILTER_HORIZONTAL: | |
1220 | ✗ | for (y = 1; y < frame->height; y++) { | |
1221 | ✗ | dec = frame->data[3] + y * ls + 1; | |
1222 | ✗ | for (x = 1; x < frame->width; x++, dec++) | |
1223 | ✗ | *dec += *(dec - 1); | |
1224 | } | ||
1225 | ✗ | break; | |
1226 | ✗ | case ALPHA_FILTER_VERTICAL: | |
1227 | ✗ | for (y = 1; y < frame->height; y++) { | |
1228 | ✗ | dec = frame->data[3] + y * ls + 1; | |
1229 | ✗ | for (x = 1; x < frame->width; x++, dec++) | |
1230 | ✗ | *dec += *(dec - ls); | |
1231 | } | ||
1232 | ✗ | break; | |
1233 | ✗ | case ALPHA_FILTER_GRADIENT: | |
1234 | ✗ | for (y = 1; y < frame->height; y++) { | |
1235 | ✗ | dec = frame->data[3] + y * ls + 1; | |
1236 | ✗ | for (x = 1; x < frame->width; x++, dec++) | |
1237 | ✗ | dec[0] += av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1)); | |
1238 | } | ||
1239 | ✗ | break; | |
1240 | } | ||
1241 | ✗ | } | |
1242 | |||
1243 | 2 | static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p, | |
1244 | const uint8_t *data_start, | ||
1245 | unsigned int data_size) | ||
1246 | { | ||
1247 | 2 | WebPContext *s = avctx->priv_data; | |
1248 | int x, y, ret; | ||
1249 | |||
1250 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (s->alpha_compression == ALPHA_COMPRESSION_NONE) { |
1251 | GetByteContext gb; | ||
1252 | |||
1253 | ✗ | bytestream2_init(&gb, data_start, data_size); | |
1254 | ✗ | for (y = 0; y < s->height; y++) | |
1255 | ✗ | bytestream2_get_buffer(&gb, p->data[3] + p->linesize[3] * y, | |
1256 | ✗ | s->width); | |
1257 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | } else if (s->alpha_compression == ALPHA_COMPRESSION_VP8L) { |
1258 | uint8_t *ap, *pp; | ||
1259 | 2 | int alpha_got_frame = 0; | |
1260 | |||
1261 | 2 | s->alpha_frame = av_frame_alloc(); | |
1262 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!s->alpha_frame) |
1263 | ✗ | return AVERROR(ENOMEM); | |
1264 | |||
1265 | 2 | ret = vp8_lossless_decode_frame(avctx, s->alpha_frame, &alpha_got_frame, | |
1266 | data_start, data_size, 1); | ||
1267 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) { |
1268 | ✗ | av_frame_free(&s->alpha_frame); | |
1269 | ✗ | return ret; | |
1270 | } | ||
1271 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!alpha_got_frame) { |
1272 | ✗ | av_frame_free(&s->alpha_frame); | |
1273 | ✗ | return AVERROR_INVALIDDATA; | |
1274 | } | ||
1275 | |||
1276 | /* copy green component of alpha image to alpha plane of primary image */ | ||
1277 |
2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
|
18 | for (y = 0; y < s->height; y++) { |
1278 | 16 | ap = GET_PIXEL(s->alpha_frame, 0, y) + 2; | |
1279 | 16 | pp = p->data[3] + p->linesize[3] * y; | |
1280 |
2/2✓ Branch 0 taken 192 times.
✓ Branch 1 taken 16 times.
|
208 | for (x = 0; x < s->width; x++) { |
1281 | 192 | *pp = *ap; | |
1282 | 192 | pp++; | |
1283 | 192 | ap += 4; | |
1284 | } | ||
1285 | } | ||
1286 | 2 | av_frame_free(&s->alpha_frame); | |
1287 | } | ||
1288 | |||
1289 | /* apply alpha filtering */ | ||
1290 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (s->alpha_filter) |
1291 | ✗ | alpha_inverse_prediction(p, s->alpha_filter); | |
1292 | |||
1293 | 2 | return 0; | |
1294 | } | ||
1295 | |||
1296 | 6 | static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p, | |
1297 | int *got_frame, uint8_t *data_start, | ||
1298 | unsigned int data_size) | ||
1299 | { | ||
1300 | 6 | WebPContext *s = avctx->priv_data; | |
1301 | int ret; | ||
1302 | |||
1303 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (!s->initialized) { |
1304 | 6 | ff_vp8_decode_init(avctx); | |
1305 | 6 | s->initialized = 1; | |
1306 | 6 | s->v.actually_webp = 1; | |
1307 | } | ||
1308 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
|
6 | avctx->pix_fmt = s->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P; |
1309 | 6 | s->lossless = 0; | |
1310 | |||
1311 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (data_size > INT_MAX) { |
1312 | ✗ | av_log(avctx, AV_LOG_ERROR, "unsupported chunk size\n"); | |
1313 | ✗ | return AVERROR_PATCHWELCOME; | |
1314 | } | ||
1315 | |||
1316 | 6 | av_packet_unref(s->pkt); | |
1317 | 6 | s->pkt->data = data_start; | |
1318 | 6 | s->pkt->size = data_size; | |
1319 | |||
1320 | 6 | ret = ff_vp8_decode_frame(avctx, p, got_frame, s->pkt); | |
1321 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
1322 | ✗ | return ret; | |
1323 | |||
1324 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (!*got_frame) |
1325 | ✗ | return AVERROR_INVALIDDATA; | |
1326 | |||
1327 | 6 | update_canvas_size(avctx, avctx->width, avctx->height); | |
1328 | |||
1329 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 4 times.
|
6 | if (s->has_alpha) { |
1330 | 2 | ret = vp8_lossy_decode_alpha(avctx, p, s->alpha_data, | |
1331 | 2 | s->alpha_data_size); | |
1332 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
1333 | ✗ | return ret; | |
1334 | } | ||
1335 | 6 | return ret; | |
1336 | } | ||
1337 | |||
1338 | 16 | static int webp_decode_frame(AVCodecContext *avctx, AVFrame *p, | |
1339 | int *got_frame, AVPacket *avpkt) | ||
1340 | { | ||
1341 | 16 | WebPContext *s = avctx->priv_data; | |
1342 | GetByteContext gb; | ||
1343 | int ret; | ||
1344 | uint32_t chunk_type, chunk_size; | ||
1345 | 16 | int vp8x_flags = 0; | |
1346 | |||
1347 | 16 | s->avctx = avctx; | |
1348 | 16 | s->width = 0; | |
1349 | 16 | s->height = 0; | |
1350 | 16 | *got_frame = 0; | |
1351 | 16 | s->has_alpha = 0; | |
1352 | 16 | s->has_exif = 0; | |
1353 | 16 | s->has_iccp = 0; | |
1354 | 16 | bytestream2_init(&gb, avpkt->data, avpkt->size); | |
1355 | |||
1356 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
|
16 | if (bytestream2_get_bytes_left(&gb) < 12) |
1357 | ✗ | return AVERROR_INVALIDDATA; | |
1358 | |||
1359 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
|
16 | if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) { |
1360 | ✗ | av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n"); | |
1361 | ✗ | return AVERROR_INVALIDDATA; | |
1362 | } | ||
1363 | |||
1364 | 16 | chunk_size = bytestream2_get_le32(&gb); | |
1365 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
|
16 | if (bytestream2_get_bytes_left(&gb) < chunk_size) |
1366 | ✗ | return AVERROR_INVALIDDATA; | |
1367 | |||
1368 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 16 times.
|
16 | if (bytestream2_get_le32(&gb) != MKTAG('W', 'E', 'B', 'P')) { |
1369 | ✗ | av_log(avctx, AV_LOG_ERROR, "missing WEBP tag\n"); | |
1370 | ✗ | return AVERROR_INVALIDDATA; | |
1371 | } | ||
1372 | |||
1373 |
2/2✓ Branch 1 taken 24 times.
✓ Branch 2 taken 16 times.
|
40 | while (bytestream2_get_bytes_left(&gb) > 8) { |
1374 | 24 | char chunk_str[5] = { 0 }; | |
1375 | |||
1376 | 24 | chunk_type = bytestream2_get_le32(&gb); | |
1377 | 24 | chunk_size = bytestream2_get_le32(&gb); | |
1378 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24 times.
|
24 | if (chunk_size == UINT32_MAX) |
1379 | ✗ | return AVERROR_INVALIDDATA; | |
1380 | 24 | chunk_size += chunk_size & 1; | |
1381 | |||
1382 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 24 times.
|
24 | if (bytestream2_get_bytes_left(&gb) < chunk_size) { |
1383 | /* we seem to be running out of data, but it could also be that the | ||
1384 | bitstream has trailing junk leading to bogus chunk_size. */ | ||
1385 | ✗ | break; | |
1386 | } | ||
1387 | |||
1388 |
5/8✓ Branch 0 taken 6 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
|
24 | switch (chunk_type) { |
1389 | 6 | case MKTAG('V', 'P', '8', ' '): | |
1390 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (!*got_frame) { |
1391 | 6 | ret = vp8_lossy_decode_frame(avctx, p, got_frame, | |
1392 | 6 | avpkt->data + bytestream2_tell(&gb), | |
1393 | chunk_size); | ||
1394 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
1395 | ✗ | return ret; | |
1396 | } | ||
1397 | 6 | bytestream2_skip(&gb, chunk_size); | |
1398 | 6 | break; | |
1399 | 10 | case MKTAG('V', 'P', '8', 'L'): | |
1400 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
10 | if (!*got_frame) { |
1401 | 10 | ret = vp8_lossless_decode_frame(avctx, p, got_frame, | |
1402 | 10 | avpkt->data + bytestream2_tell(&gb), | |
1403 | chunk_size, 0); | ||
1404 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (ret < 0) |
1405 | ✗ | return ret; | |
1406 | #if FF_API_CODEC_PROPS | ||
1407 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1408 | 10 | avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS; | |
1409 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1410 | #endif | ||
1411 | } | ||
1412 | 10 | bytestream2_skip(&gb, chunk_size); | |
1413 | 10 | break; | |
1414 | 4 | case MKTAG('V', 'P', '8', 'X'): | |
1415 |
3/6✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
4 | if (s->width || s->height || *got_frame) { |
1416 | ✗ | av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n"); | |
1417 | ✗ | return AVERROR_INVALIDDATA; | |
1418 | } | ||
1419 | 4 | vp8x_flags = bytestream2_get_byte(&gb); | |
1420 | 4 | bytestream2_skip(&gb, 3); | |
1421 | 4 | s->width = bytestream2_get_le24(&gb) + 1; | |
1422 | 4 | s->height = bytestream2_get_le24(&gb) + 1; | |
1423 | 4 | ret = av_image_check_size(s->width, s->height, 0, avctx); | |
1424 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4 | if (ret < 0) |
1425 | ✗ | return ret; | |
1426 | 4 | break; | |
1427 | 2 | case MKTAG('A', 'L', 'P', 'H'): { | |
1428 | int alpha_header, filter_m, compression; | ||
1429 | |||
1430 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!(vp8x_flags & VP8X_FLAG_ALPHA)) { |
1431 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
1432 | "ALPHA chunk present, but alpha bit not set in the " | ||
1433 | "VP8X header\n"); | ||
1434 | } | ||
1435 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (chunk_size == 0) { |
1436 | ✗ | av_log(avctx, AV_LOG_ERROR, "invalid ALPHA chunk size\n"); | |
1437 | ✗ | return AVERROR_INVALIDDATA; | |
1438 | } | ||
1439 | 2 | alpha_header = bytestream2_get_byte(&gb); | |
1440 | 2 | s->alpha_data = avpkt->data + bytestream2_tell(&gb); | |
1441 | 2 | s->alpha_data_size = chunk_size - 1; | |
1442 | 2 | bytestream2_skip(&gb, s->alpha_data_size); | |
1443 | |||
1444 | 2 | filter_m = (alpha_header >> 2) & 0x03; | |
1445 | 2 | compression = alpha_header & 0x03; | |
1446 | |||
1447 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (compression > ALPHA_COMPRESSION_VP8L) { |
1448 | ✗ | av_log(avctx, AV_LOG_VERBOSE, | |
1449 | "skipping unsupported ALPHA chunk\n"); | ||
1450 | } else { | ||
1451 | 2 | s->has_alpha = 1; | |
1452 | 2 | s->alpha_compression = compression; | |
1453 | 2 | s->alpha_filter = filter_m; | |
1454 | } | ||
1455 | |||
1456 | 2 | break; | |
1457 | } | ||
1458 | 2 | case MKTAG('E', 'X', 'I', 'F'): { | |
1459 | 2 | int le, ifd_offset, exif_offset = bytestream2_tell(&gb); | |
1460 | 2 | AVDictionary *exif_metadata = NULL; | |
1461 | GetByteContext exif_gb; | ||
1462 | |||
1463 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (s->has_exif) { |
1464 | ✗ | av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra EXIF chunk\n"); | |
1465 | ✗ | goto exif_end; | |
1466 | } | ||
1467 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!(vp8x_flags & VP8X_FLAG_EXIF_METADATA)) |
1468 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
1469 | "EXIF chunk present, but Exif bit not set in the " | ||
1470 | "VP8X header\n"); | ||
1471 | |||
1472 | 2 | s->has_exif = 1; | |
1473 | 2 | bytestream2_init(&exif_gb, avpkt->data + exif_offset, | |
1474 | 2 | avpkt->size - exif_offset); | |
1475 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | if (ff_tdecode_header(&exif_gb, &le, &ifd_offset) < 0) { |
1476 | ✗ | av_log(avctx, AV_LOG_ERROR, "invalid TIFF header " | |
1477 | "in Exif data\n"); | ||
1478 | ✗ | goto exif_end; | |
1479 | } | ||
1480 | |||
1481 | 2 | bytestream2_seek(&exif_gb, ifd_offset, SEEK_SET); | |
1482 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | if (ff_exif_decode_ifd(avctx, &exif_gb, le, 0, &exif_metadata) < 0) { |
1483 | ✗ | av_log(avctx, AV_LOG_ERROR, "error decoding Exif data\n"); | |
1484 | ✗ | goto exif_end; | |
1485 | } | ||
1486 | |||
1487 | 2 | av_dict_copy(&p->metadata, exif_metadata, 0); | |
1488 | |||
1489 | 2 | exif_end: | |
1490 | 2 | av_dict_free(&exif_metadata); | |
1491 | 2 | bytestream2_skip(&gb, chunk_size); | |
1492 | 2 | break; | |
1493 | } | ||
1494 | ✗ | case MKTAG('I', 'C', 'C', 'P'): { | |
1495 | AVFrameSideData *sd; | ||
1496 | |||
1497 | ✗ | if (s->has_iccp) { | |
1498 | ✗ | av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n"); | |
1499 | ✗ | bytestream2_skip(&gb, chunk_size); | |
1500 | ✗ | break; | |
1501 | } | ||
1502 | ✗ | if (!(vp8x_flags & VP8X_FLAG_ICC)) | |
1503 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
1504 | "ICCP chunk present, but ICC Profile bit not set in the " | ||
1505 | "VP8X header\n"); | ||
1506 | |||
1507 | ✗ | s->has_iccp = 1; | |
1508 | |||
1509 | ✗ | ret = ff_frame_new_side_data(avctx, p, AV_FRAME_DATA_ICC_PROFILE, chunk_size, &sd); | |
1510 | ✗ | if (ret < 0) | |
1511 | ✗ | return ret; | |
1512 | |||
1513 | ✗ | if (sd) { | |
1514 | ✗ | bytestream2_get_buffer(&gb, sd->data, chunk_size); | |
1515 | } else { | ||
1516 | ✗ | bytestream2_skip(&gb, chunk_size); | |
1517 | } | ||
1518 | ✗ | break; | |
1519 | } | ||
1520 | ✗ | case MKTAG('A', 'N', 'I', 'M'): | |
1521 | case MKTAG('A', 'N', 'M', 'F'): | ||
1522 | case MKTAG('X', 'M', 'P', ' '): | ||
1523 | ✗ | AV_WL32(chunk_str, chunk_type); | |
1524 | ✗ | av_log(avctx, AV_LOG_WARNING, "skipping unsupported chunk: %s\n", | |
1525 | chunk_str); | ||
1526 | ✗ | bytestream2_skip(&gb, chunk_size); | |
1527 | ✗ | break; | |
1528 | ✗ | default: | |
1529 | ✗ | AV_WL32(chunk_str, chunk_type); | |
1530 | ✗ | av_log(avctx, AV_LOG_VERBOSE, "skipping unknown chunk: %s\n", | |
1531 | chunk_str); | ||
1532 | ✗ | bytestream2_skip(&gb, chunk_size); | |
1533 | ✗ | break; | |
1534 | } | ||
1535 | } | ||
1536 | |||
1537 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | if (!*got_frame) { |
1538 | ✗ | av_log(avctx, AV_LOG_ERROR, "image data not found\n"); | |
1539 | ✗ | return AVERROR_INVALIDDATA; | |
1540 | } | ||
1541 | |||
1542 | 16 | return avpkt->size; | |
1543 | } | ||
1544 | |||
1545 | 16 | static av_cold int webp_decode_init(AVCodecContext *avctx) | |
1546 | { | ||
1547 | 16 | WebPContext *s = avctx->priv_data; | |
1548 | |||
1549 | 16 | s->pkt = av_packet_alloc(); | |
1550 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16 times.
|
16 | if (!s->pkt) |
1551 | ✗ | return AVERROR(ENOMEM); | |
1552 | |||
1553 | 16 | return 0; | |
1554 | } | ||
1555 | |||
1556 | 16 | static av_cold int webp_decode_close(AVCodecContext *avctx) | |
1557 | { | ||
1558 | 16 | WebPContext *s = avctx->priv_data; | |
1559 | |||
1560 | 16 | av_packet_free(&s->pkt); | |
1561 | |||
1562 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 10 times.
|
16 | if (s->initialized) |
1563 | 6 | return ff_vp8_decode_free(avctx); | |
1564 | |||
1565 | 10 | return 0; | |
1566 | } | ||
1567 | |||
1568 | const FFCodec ff_webp_decoder = { | ||
1569 | .p.name = "webp", | ||
1570 | CODEC_LONG_NAME("WebP image"), | ||
1571 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1572 | .p.id = AV_CODEC_ID_WEBP, | ||
1573 | .priv_data_size = sizeof(WebPContext), | ||
1574 | .init = webp_decode_init, | ||
1575 | FF_CODEC_DECODE_CB(webp_decode_frame), | ||
1576 | .close = webp_decode_close, | ||
1577 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, | ||
1578 | .caps_internal = FF_CODEC_CAP_ICC_PROFILES | | ||
1579 | FF_CODEC_CAP_USES_PROGRESSFRAMES, | ||
1580 | }; | ||
1581 |