2 * WebP (.webp) image decoder
3 * Copyright (c) 2013 Aneesh Dogra <aneesh@sugarlabs.org>
4 * Copyright (c) 2013 Justin Ruggles <justin.ruggles@gmail.com>
6 * This file is part of FFmpeg.
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.
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.
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
27 * @author Aneesh Dogra <aneesh@sugarlabs.org>
28 * Container and Lossy decoding
30 * @author Justin Ruggles <justin.ruggles@gmail.com>
32 * Compressed alpha for lossy
34 * @author James Almer <jamrial@gmail.com>
43 #define BITSTREAM_READER_LE
44 #include "libavutil/imgutils.h"
46 #include "bytestream.h"
53 #define VP8X_FLAG_ANIMATION 0x02
54 #define VP8X_FLAG_XMP_METADATA 0x04
55 #define VP8X_FLAG_EXIF_METADATA 0x08
56 #define VP8X_FLAG_ALPHA 0x10
57 #define VP8X_FLAG_ICC 0x20
59 #define MAX_PALETTE_SIZE 256
60 #define MAX_CACHE_BITS 11
61 #define NUM_CODE_LENGTH_CODES 19
62 #define HUFFMAN_CODES_PER_META_CODE 5
63 #define NUM_LITERAL_CODES 256
64 #define NUM_LENGTH_CODES 24
65 #define NUM_DISTANCE_CODES 40
66 #define NUM_SHORT_DISTANCES 120
67 #define MAX_HUFFMAN_CODE_LENGTH 15
69 static const uint16_t alphabet_sizes
[HUFFMAN_CODES_PER_META_CODE
] = {
70 NUM_LITERAL_CODES
+ NUM_LENGTH_CODES
,
71 NUM_LITERAL_CODES
, NUM_LITERAL_CODES
, NUM_LITERAL_CODES
,
75 static const uint8_t code_length_code_order
[NUM_CODE_LENGTH_CODES
] = {
76 17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
79 static const int8_t lz77_distance_offsets
[NUM_SHORT_DISTANCES
][2] = {
80 { 0, 1 }, { 1, 0 }, { 1, 1 }, { -1, 1 }, { 0, 2 }, { 2, 0 }, { 1, 2 }, { -1, 2 },
81 { 2, 1 }, { -2, 1 }, { 2, 2 }, { -2, 2 }, { 0, 3 }, { 3, 0 }, { 1, 3 }, { -1, 3 },
82 { 3, 1 }, { -3, 1 }, { 2, 3 }, { -2, 3 }, { 3, 2 }, { -3, 2 }, { 0, 4 }, { 4, 0 },
83 { 1, 4 }, { -1, 4 }, { 4, 1 }, { -4, 1 }, { 3, 3 }, { -3, 3 }, { 2, 4 }, { -2, 4 },
84 { 4, 2 }, { -4, 2 }, { 0, 5 }, { 3, 4 }, { -3, 4 }, { 4, 3 }, { -4, 3 }, { 5, 0 },
85 { 1, 5 }, { -1, 5 }, { 5, 1 }, { -5, 1 }, { 2, 5 }, { -2, 5 }, { 5, 2 }, { -5, 2 },
86 { 4, 4 }, { -4, 4 }, { 3, 5 }, { -3, 5 }, { 5, 3 }, { -5, 3 }, { 0, 6 }, { 6, 0 },
87 { 1, 6 }, { -1, 6 }, { 6, 1 }, { -6, 1 }, { 2, 6 }, { -2, 6 }, { 6, 2 }, { -6, 2 },
88 { 4, 5 }, { -4, 5 }, { 5, 4 }, { -5, 4 }, { 3, 6 }, { -3, 6 }, { 6, 3 }, { -6, 3 },
89 { 0, 7 }, { 7, 0 }, { 1, 7 }, { -1, 7 }, { 5, 5 }, { -5, 5 }, { 7, 1 }, { -7, 1 },
90 { 4, 6 }, { -4, 6 }, { 6, 4 }, { -6, 4 }, { 2, 7 }, { -2, 7 }, { 7, 2 }, { -7, 2 },
91 { 3, 7 }, { -3, 7 }, { 7, 3 }, { -7, 3 }, { 5, 6 }, { -5, 6 }, { 6, 5 }, { -6, 5 },
92 { 8, 0 }, { 4, 7 }, { -4, 7 }, { 7, 4 }, { -7, 4 }, { 8, 1 }, { 8, 2 }, { 6, 6 },
93 { -6, 6 }, { 8, 3 }, { 5, 7 }, { -5, 7 }, { 7, 5 }, { -7, 5 }, { 8, 4 }, { 6, 7 },
94 { -6, 7 }, { 7, 6 }, { -7, 6 }, { 8, 5 }, { 7, 7 }, { -7, 7 }, { 8, 6 }, { 8, 7 }
97 enum AlphaCompression
{
98 ALPHA_COMPRESSION_NONE
,
99 ALPHA_COMPRESSION_VP8L
,
104 ALPHA_FILTER_HORIZONTAL
,
105 ALPHA_FILTER_VERTICAL
,
106 ALPHA_FILTER_GRADIENT
,
110 PREDICTOR_TRANSFORM
= 0,
113 COLOR_INDEXING_TRANSFORM
= 3,
116 enum PredictionMode
{
122 PRED_MODE_AVG_T_AVG_L_TR
,
127 PRED_MODE_AVG_AVG_L_TL_AVG_T_TR
,
129 PRED_MODE_ADD_SUBTRACT_FULL
,
130 PRED_MODE_ADD_SUBTRACT_HALF
,
141 /* The structure of WebP lossless is an optional series of transformation data,
142 * followed by the primary image. The primary image also optionally contains
143 * an entropy group mapping if there are multiple entropy groups. There is a
144 * basic image type called an "entropy coded image" that is used for all of
145 * these. The type of each entropy coded image is referred to by the
146 * specification as its role. */
148 /* Primary Image: Stores the actual pixels of the image. */
151 /* Entropy Image: Defines which Huffman group to use for different areas of
152 * the primary image. */
155 /* Predictors: Defines which predictor type to use for different areas of
156 * the primary image. */
157 IMAGE_ROLE_PREDICTOR
,
159 /* Color Transform Data: Defines the color transformation for different
160 * areas of the primary image. */
161 IMAGE_ROLE_COLOR_TRANSFORM
,
163 /* Color Index: Stored as an image of height == 1. */
164 IMAGE_ROLE_COLOR_INDEXING
,
169 typedef struct HuffReader
{
170 VLC vlc
; /* Huffman decoder context */
171 int simple
; /* whether to use simple mode */
172 int nb_symbols
; /* number of coded symbols */
173 uint16_t simple_symbols
[2]; /* symbols for simple mode */
176 typedef struct ImageContext
{
177 enum ImageRole role
; /* role of this image */
178 AVFrame
*frame
; /* AVFrame for data */
179 int color_cache_bits
; /* color cache size, log2 */
180 uint32_t *color_cache
; /* color cache data */
181 int nb_huffman_groups
; /* number of huffman groups */
182 HuffReader
*huffman_groups
; /* reader for each huffman group */
183 int size_reduction
; /* relative size compared to primary image, log2 */
184 int is_alpha_primary
;
187 typedef struct WebPContext
{
188 VP8Context v
; /* VP8 Context used for lossy decoding */
189 GetBitContext gb
; /* bitstream reader for main image chunk */
190 AVFrame
*alpha_frame
; /* AVFrame for alpha data decompressed from VP8L */
191 AVCodecContext
*avctx
; /* parent AVCodecContext */
192 int initialized
; /* set once the VP8 context is initialized */
193 int has_alpha
; /* has a separate alpha chunk */
194 enum AlphaCompression alpha_compression
; /* compression type for alpha chunk */
195 enum AlphaFilter alpha_filter
; /* filtering method for alpha chunk */
196 uint8_t *alpha_data
; /* alpha chunk data */
197 int alpha_data_size
; /* alpha chunk data size */
198 int has_exif
; /* set after an EXIF chunk has been processed */
199 AVDictionary
*exif_metadata
; /* EXIF chunk data */
200 int width
; /* image width */
201 int height
; /* image height */
202 int lossless
; /* indicates lossless or lossy */
204 int nb_transforms
; /* number of transforms */
205 enum TransformType transforms
[4]; /* transformations used in the image, in order */
206 int reduced_width
; /* reduced width for index image, if applicable */
207 int nb_huffman_groups
; /* number of huffman groups in the primary image */
208 ImageContext image
[IMAGE_ROLE_NB
]; /* image context for each role */
211 #define GET_PIXEL(frame, x, y) \
212 ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
214 #define GET_PIXEL_COMP(frame, x, y, c) \
215 (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
217 static void image_ctx_free(ImageContext
*img
)
221 av_free(img
->color_cache
);
222 if (img
->role
!= IMAGE_ROLE_ARGB
&& !img
->is_alpha_primary
)
223 av_frame_free(&img
->frame
);
224 if (img
->huffman_groups
) {
225 for (i
= 0; i
< img
->nb_huffman_groups
; i
++) {
226 for (j
= 0; j
< HUFFMAN_CODES_PER_META_CODE
; j
++)
227 ff_free_vlc(&img
->huffman_groups
[i
* HUFFMAN_CODES_PER_META_CODE
+ j
].vlc
);
229 av_free(img
->huffman_groups
);
231 memset(img
, 0, sizeof(*img
));
235 /* Differs from get_vlc2() in the following ways:
236 * - codes are bit-reversed
237 * - assumes 8-bit table to make reversal simpler
238 * - assumes max depth of 2 since the max code length for WebP is 15
240 static av_always_inline
int webp_get_vlc(GetBitContext
*gb
, VLC_TYPE (*table
)[2])
247 UPDATE_CACHE(re
, gb
);
249 index
= SHOW_UBITS(re
, gb
, 8);
250 index
= ff_reverse
[index
];
251 code
= table
[index
][0];
255 LAST_SKIP_BITS(re
, gb
, 8);
256 UPDATE_CACHE(re
, gb
);
260 index
= SHOW_UBITS(re
, gb
, nb_bits
);
261 index
= (ff_reverse
[index
] >> (8 - nb_bits
)) + code
;
262 code
= table
[index
][0];
265 SKIP_BITS(re
, gb
, n
);
267 CLOSE_READER(re
, gb
);
272 static int huff_reader_get_symbol(HuffReader
*r
, GetBitContext
*gb
)
275 if (r
->nb_symbols
== 1)
276 return r
->simple_symbols
[0];
278 return r
->simple_symbols
[get_bits1(gb
)];
280 return webp_get_vlc(gb
, r
->vlc
.table
);
283 static int huff_reader_build_canonical(HuffReader
*r
, int *code_lengths
,
286 int len
= 0, sym
, code
= 0, ret
;
287 int max_code_length
= 0;
290 /* special-case 1 symbol since the vlc reader cannot handle it */
291 for (sym
= 0; sym
< alphabet_size
; sym
++) {
292 if (code_lengths
[sym
] > 0) {
301 r
->simple_symbols
[0] = code
;
306 for (sym
= 0; sym
< alphabet_size
; sym
++)
307 max_code_length
= FFMAX(max_code_length
, code_lengths
[sym
]);
309 if (max_code_length
== 0 || max_code_length
> MAX_HUFFMAN_CODE_LENGTH
)
310 return AVERROR(EINVAL
);
312 codes
= av_malloc_array(alphabet_size
, sizeof(*codes
));
314 return AVERROR(ENOMEM
);
318 for (len
= 1; len
<= max_code_length
; len
++) {
319 for (sym
= 0; sym
< alphabet_size
; sym
++) {
320 if (code_lengths
[sym
] != len
)
327 if (!r
->nb_symbols
) {
329 return AVERROR_INVALIDDATA
;
332 ret
= init_vlc(&r
->vlc
, 8, alphabet_size
,
333 code_lengths
, sizeof(*code_lengths
), sizeof(*code_lengths
),
334 codes
, sizeof(*codes
), sizeof(*codes
), 0);
345 static void read_huffman_code_simple(WebPContext
*s
, HuffReader
*hc
)
347 hc
->nb_symbols
= get_bits1(&s
->gb
) + 1;
349 if (get_bits1(&s
->gb
))
350 hc
->simple_symbols
[0] = get_bits(&s
->gb
, 8);
352 hc
->simple_symbols
[0] = get_bits1(&s
->gb
);
354 if (hc
->nb_symbols
== 2)
355 hc
->simple_symbols
[1] = get_bits(&s
->gb
, 8);
360 static int read_huffman_code_normal(WebPContext
*s
, HuffReader
*hc
,
363 HuffReader code_len_hc
= { { 0 }, 0, 0, { 0 } };
364 int *code_lengths
= NULL
;
365 int code_length_code_lengths
[NUM_CODE_LENGTH_CODES
] = { 0 };
366 int i
, symbol
, max_symbol
, prev_code_len
, ret
;
367 int num_codes
= 4 + get_bits(&s
->gb
, 4);
369 if (num_codes
> NUM_CODE_LENGTH_CODES
)
370 return AVERROR_INVALIDDATA
;
372 for (i
= 0; i
< num_codes
; i
++)
373 code_length_code_lengths
[code_length_code_order
[i
]] = get_bits(&s
->gb
, 3);
375 ret
= huff_reader_build_canonical(&code_len_hc
, code_length_code_lengths
,
376 NUM_CODE_LENGTH_CODES
);
380 code_lengths
= av_mallocz_array(alphabet_size
, sizeof(*code_lengths
));
382 ret
= AVERROR(ENOMEM
);
386 if (get_bits1(&s
->gb
)) {
387 int bits
= 2 + 2 * get_bits(&s
->gb
, 3);
388 max_symbol
= 2 + get_bits(&s
->gb
, bits
);
389 if (max_symbol
> alphabet_size
) {
390 av_log(s
->avctx
, AV_LOG_ERROR
, "max symbol %d > alphabet size %d\n",
391 max_symbol
, alphabet_size
);
392 ret
= AVERROR_INVALIDDATA
;
396 max_symbol
= alphabet_size
;
401 while (symbol
< alphabet_size
) {
406 code_len
= huff_reader_get_symbol(&code_len_hc
, &s
->gb
);
408 /* Code length code [0..15] indicates literal code lengths. */
409 code_lengths
[symbol
++] = code_len
;
411 prev_code_len
= code_len
;
413 int repeat
= 0, length
= 0;
416 /* Code 16 repeats the previous non-zero value [3..6] times,
417 * i.e., 3 + ReadBits(2) times. If code 16 is used before a
418 * non-zero value has been emitted, a value of 8 is repeated. */
419 repeat
= 3 + get_bits(&s
->gb
, 2);
420 length
= prev_code_len
;
423 /* Code 17 emits a streak of zeros [3..10], i.e.,
424 * 3 + ReadBits(3) times. */
425 repeat
= 3 + get_bits(&s
->gb
, 3);
428 /* Code 18 emits a streak of zeros of length [11..138], i.e.,
429 * 11 + ReadBits(7) times. */
430 repeat
= 11 + get_bits(&s
->gb
, 7);
433 if (symbol
+ repeat
> alphabet_size
) {
434 av_log(s
->avctx
, AV_LOG_ERROR
,
435 "invalid symbol %d + repeat %d > alphabet size %d\n",
436 symbol
, repeat
, alphabet_size
);
437 ret
= AVERROR_INVALIDDATA
;
441 code_lengths
[symbol
++] = length
;
445 ret
= huff_reader_build_canonical(hc
, code_lengths
, alphabet_size
);
448 ff_free_vlc(&code_len_hc
.vlc
);
449 av_free(code_lengths
);
453 static int decode_entropy_coded_image(WebPContext
*s
, enum ImageRole role
,
456 #define PARSE_BLOCK_SIZE(w, h) do { \
457 block_bits = get_bits(&s->gb, 3) + 2; \
458 blocks_w = FFALIGN((w), 1 << block_bits) >> block_bits; \
459 blocks_h = FFALIGN((h), 1 << block_bits) >> block_bits; \
462 static int decode_entropy_image(WebPContext
*s
)
465 int ret
, block_bits
, width
, blocks_w
, blocks_h
, x
, y
, max
;
468 if (s
->reduced_width
> 0)
469 width
= s
->reduced_width
;
471 PARSE_BLOCK_SIZE(width
, s
->height
);
473 ret
= decode_entropy_coded_image(s
, IMAGE_ROLE_ENTROPY
, blocks_w
, blocks_h
);
477 img
= &s
->image
[IMAGE_ROLE_ENTROPY
];
478 img
->size_reduction
= block_bits
;
480 /* the number of huffman groups is determined by the maximum group number
481 * coded in the entropy image */
483 for (y
= 0; y
< img
->frame
->height
; y
++) {
484 for (x
= 0; x
< img
->frame
->width
; x
++) {
485 int p0
= GET_PIXEL_COMP(img
->frame
, x
, y
, 1);
486 int p1
= GET_PIXEL_COMP(img
->frame
, x
, y
, 2);
487 int p
= p0
<< 8 | p1
;
491 s
->nb_huffman_groups
= max
+ 1;
496 static int parse_transform_predictor(WebPContext
*s
)
498 int block_bits
, blocks_w
, blocks_h
, ret
;
500 PARSE_BLOCK_SIZE(s
->width
, s
->height
);
502 ret
= decode_entropy_coded_image(s
, IMAGE_ROLE_PREDICTOR
, blocks_w
,
507 s
->image
[IMAGE_ROLE_PREDICTOR
].size_reduction
= block_bits
;
512 static int parse_transform_color(WebPContext
*s
)
514 int block_bits
, blocks_w
, blocks_h
, ret
;
516 PARSE_BLOCK_SIZE(s
->width
, s
->height
);
518 ret
= decode_entropy_coded_image(s
, IMAGE_ROLE_COLOR_TRANSFORM
, blocks_w
,
523 s
->image
[IMAGE_ROLE_COLOR_TRANSFORM
].size_reduction
= block_bits
;
528 static int parse_transform_color_indexing(WebPContext
*s
)
531 int width_bits
, index_size
, ret
, x
;
534 index_size
= get_bits(&s
->gb
, 8) + 1;
538 else if (index_size
<= 4)
540 else if (index_size
<= 16)
545 ret
= decode_entropy_coded_image(s
, IMAGE_ROLE_COLOR_INDEXING
,
550 img
= &s
->image
[IMAGE_ROLE_COLOR_INDEXING
];
551 img
->size_reduction
= width_bits
;
553 s
->reduced_width
= (s
->width
+ ((1 << width_bits
) - 1)) >> width_bits
;
555 /* color index values are delta-coded */
556 ct
= img
->frame
->data
[0] + 4;
557 for (x
= 4; x
< img
->frame
->width
* 4; x
++, ct
++)
563 static HuffReader
*get_huffman_group(WebPContext
*s
, ImageContext
*img
,
566 ImageContext
*gimg
= &s
->image
[IMAGE_ROLE_ENTROPY
];
569 if (gimg
->size_reduction
> 0) {
570 int group_x
= x
>> gimg
->size_reduction
;
571 int group_y
= y
>> gimg
->size_reduction
;
572 int g0
= GET_PIXEL_COMP(gimg
->frame
, group_x
, group_y
, 1);
573 int g1
= GET_PIXEL_COMP(gimg
->frame
, group_x
, group_y
, 2);
574 group
= g0
<< 8 | g1
;
577 return &img
->huffman_groups
[group
* HUFFMAN_CODES_PER_META_CODE
];
580 static av_always_inline
void color_cache_put(ImageContext
*img
, uint32_t c
)
582 uint32_t cache_idx
= (0x1E35A7BD * c
) >> (32 - img
->color_cache_bits
);
583 img
->color_cache
[cache_idx
] = c
;
586 static int decode_entropy_coded_image(WebPContext
*s
, enum ImageRole role
,
591 int i
, j
, ret
, x
, y
, width
;
593 img
= &s
->image
[role
];
597 img
->frame
= av_frame_alloc();
599 return AVERROR(ENOMEM
);
602 img
->frame
->format
= AV_PIX_FMT_ARGB
;
603 img
->frame
->width
= w
;
604 img
->frame
->height
= h
;
606 if (role
== IMAGE_ROLE_ARGB
&& !img
->is_alpha_primary
) {
607 ThreadFrame pt
= { .f
= img
->frame
};
608 ret
= ff_thread_get_buffer(s
->avctx
, &pt
, 0);
610 ret
= av_frame_get_buffer(img
->frame
, 1);
614 if (get_bits1(&s
->gb
)) {
615 img
->color_cache_bits
= get_bits(&s
->gb
, 4);
616 if (img
->color_cache_bits
< 1 || img
->color_cache_bits
> 11) {
617 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid color cache bits: %d\n",
618 img
->color_cache_bits
);
619 return AVERROR_INVALIDDATA
;
621 img
->color_cache
= av_mallocz_array(1 << img
->color_cache_bits
,
622 sizeof(*img
->color_cache
));
623 if (!img
->color_cache
)
624 return AVERROR(ENOMEM
);
626 img
->color_cache_bits
= 0;
629 img
->nb_huffman_groups
= 1;
630 if (role
== IMAGE_ROLE_ARGB
&& get_bits1(&s
->gb
)) {
631 ret
= decode_entropy_image(s
);
634 img
->nb_huffman_groups
= s
->nb_huffman_groups
;
636 img
->huffman_groups
= av_mallocz_array(img
->nb_huffman_groups
*
637 HUFFMAN_CODES_PER_META_CODE
,
638 sizeof(*img
->huffman_groups
));
639 if (!img
->huffman_groups
)
640 return AVERROR(ENOMEM
);
642 for (i
= 0; i
< img
->nb_huffman_groups
; i
++) {
643 hg
= &img
->huffman_groups
[i
* HUFFMAN_CODES_PER_META_CODE
];
644 for (j
= 0; j
< HUFFMAN_CODES_PER_META_CODE
; j
++) {
645 int alphabet_size
= alphabet_sizes
[j
];
646 if (!j
&& img
->color_cache_bits
> 0)
647 alphabet_size
+= 1 << img
->color_cache_bits
;
649 if (get_bits1(&s
->gb
)) {
650 read_huffman_code_simple(s
, &hg
[j
]);
652 ret
= read_huffman_code_normal(s
, &hg
[j
], alphabet_size
);
659 width
= img
->frame
->width
;
660 if (role
== IMAGE_ROLE_ARGB
&& s
->reduced_width
> 0)
661 width
= s
->reduced_width
;
664 while (y
< img
->frame
->height
) {
667 hg
= get_huffman_group(s
, img
, x
, y
);
668 v
= huff_reader_get_symbol(&hg
[HUFF_IDX_GREEN
], &s
->gb
);
669 if (v
< NUM_LITERAL_CODES
) {
670 /* literal pixel values */
671 uint8_t *p
= GET_PIXEL(img
->frame
, x
, y
);
673 p
[1] = huff_reader_get_symbol(&hg
[HUFF_IDX_RED
], &s
->gb
);
674 p
[3] = huff_reader_get_symbol(&hg
[HUFF_IDX_BLUE
], &s
->gb
);
675 p
[0] = huff_reader_get_symbol(&hg
[HUFF_IDX_ALPHA
], &s
->gb
);
676 if (img
->color_cache_bits
)
677 color_cache_put(img
, AV_RB32(p
));
683 } else if (v
< NUM_LITERAL_CODES
+ NUM_LENGTH_CODES
) {
684 /* LZ77 backwards mapping */
685 int prefix_code
, length
, distance
, ref_x
, ref_y
;
687 /* parse length and distance */
688 prefix_code
= v
- NUM_LITERAL_CODES
;
689 if (prefix_code
< 4) {
690 length
= prefix_code
+ 1;
692 int extra_bits
= (prefix_code
- 2) >> 1;
693 int offset
= 2 + (prefix_code
& 1) << extra_bits
;
694 length
= offset
+ get_bits(&s
->gb
, extra_bits
) + 1;
696 prefix_code
= huff_reader_get_symbol(&hg
[HUFF_IDX_DIST
], &s
->gb
);
697 if (prefix_code
< 4) {
698 distance
= prefix_code
+ 1;
700 int extra_bits
= prefix_code
- 2 >> 1;
701 int offset
= 2 + (prefix_code
& 1) << extra_bits
;
702 distance
= offset
+ get_bits(&s
->gb
, extra_bits
) + 1;
705 /* find reference location */
706 if (distance
<= NUM_SHORT_DISTANCES
) {
707 int xi
= lz77_distance_offsets
[distance
- 1][0];
708 int yi
= lz77_distance_offsets
[distance
- 1][1];
709 distance
= FFMAX(1, xi
+ yi
* width
);
711 distance
-= NUM_SHORT_DISTANCES
;
722 while (distance
>= width
) {
727 ref_x
= width
- distance
;
730 ref_x
= FFMAX(0, ref_x
);
731 ref_y
= FFMAX(0, ref_y
);
734 * source and dest regions can overlap and wrap lines, so just
736 for (i
= 0; i
< length
; i
++) {
737 uint8_t *p_ref
= GET_PIXEL(img
->frame
, ref_x
, ref_y
);
738 uint8_t *p
= GET_PIXEL(img
->frame
, x
, y
);
741 if (img
->color_cache_bits
)
742 color_cache_put(img
, AV_RB32(p
));
749 if (ref_x
== width
) {
753 if (y
== img
->frame
->height
|| ref_y
== img
->frame
->height
)
757 /* read from color cache */
758 uint8_t *p
= GET_PIXEL(img
->frame
, x
, y
);
759 int cache_idx
= v
- (NUM_LITERAL_CODES
+ NUM_LENGTH_CODES
);
761 if (!img
->color_cache_bits
) {
762 av_log(s
->avctx
, AV_LOG_ERROR
, "color cache not found\n");
763 return AVERROR_INVALIDDATA
;
765 if (cache_idx
>= 1 << img
->color_cache_bits
) {
766 av_log(s
->avctx
, AV_LOG_ERROR
,
767 "color cache index out-of-bounds\n");
768 return AVERROR_INVALIDDATA
;
770 AV_WB32(p
, img
->color_cache
[cache_idx
]);
782 /* PRED_MODE_BLACK */
783 static void inv_predict_0(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
784 const uint8_t *p_t
, const uint8_t *p_tr
)
786 AV_WB32(p
, 0xFF000000);
790 static void inv_predict_1(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
791 const uint8_t *p_t
, const uint8_t *p_tr
)
797 static void inv_predict_2(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
798 const uint8_t *p_t
, const uint8_t *p_tr
)
804 static void inv_predict_3(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
805 const uint8_t *p_t
, const uint8_t *p_tr
)
811 static void inv_predict_4(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
812 const uint8_t *p_t
, const uint8_t *p_tr
)
817 /* PRED_MODE_AVG_T_AVG_L_TR */
818 static void inv_predict_5(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
819 const uint8_t *p_t
, const uint8_t *p_tr
)
821 p
[0] = p_t
[0] + (p_l
[0] + p_tr
[0] >> 1) >> 1;
822 p
[1] = p_t
[1] + (p_l
[1] + p_tr
[1] >> 1) >> 1;
823 p
[2] = p_t
[2] + (p_l
[2] + p_tr
[2] >> 1) >> 1;
824 p
[3] = p_t
[3] + (p_l
[3] + p_tr
[3] >> 1) >> 1;
827 /* PRED_MODE_AVG_L_TL */
828 static void inv_predict_6(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
829 const uint8_t *p_t
, const uint8_t *p_tr
)
831 p
[0] = p_l
[0] + p_tl
[0] >> 1;
832 p
[1] = p_l
[1] + p_tl
[1] >> 1;
833 p
[2] = p_l
[2] + p_tl
[2] >> 1;
834 p
[3] = p_l
[3] + p_tl
[3] >> 1;
837 /* PRED_MODE_AVG_L_T */
838 static void inv_predict_7(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
839 const uint8_t *p_t
, const uint8_t *p_tr
)
841 p
[0] = p_l
[0] + p_t
[0] >> 1;
842 p
[1] = p_l
[1] + p_t
[1] >> 1;
843 p
[2] = p_l
[2] + p_t
[2] >> 1;
844 p
[3] = p_l
[3] + p_t
[3] >> 1;
847 /* PRED_MODE_AVG_TL_T */
848 static void inv_predict_8(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
849 const uint8_t *p_t
, const uint8_t *p_tr
)
851 p
[0] = p_tl
[0] + p_t
[0] >> 1;
852 p
[1] = p_tl
[1] + p_t
[1] >> 1;
853 p
[2] = p_tl
[2] + p_t
[2] >> 1;
854 p
[3] = p_tl
[3] + p_t
[3] >> 1;
857 /* PRED_MODE_AVG_T_TR */
858 static void inv_predict_9(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
859 const uint8_t *p_t
, const uint8_t *p_tr
)
861 p
[0] = p_t
[0] + p_tr
[0] >> 1;
862 p
[1] = p_t
[1] + p_tr
[1] >> 1;
863 p
[2] = p_t
[2] + p_tr
[2] >> 1;
864 p
[3] = p_t
[3] + p_tr
[3] >> 1;
867 /* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */
868 static void inv_predict_10(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
869 const uint8_t *p_t
, const uint8_t *p_tr
)
871 p
[0] = (p_l
[0] + p_tl
[0] >> 1) + (p_t
[0] + p_tr
[0] >> 1) >> 1;
872 p
[1] = (p_l
[1] + p_tl
[1] >> 1) + (p_t
[1] + p_tr
[1] >> 1) >> 1;
873 p
[2] = (p_l
[2] + p_tl
[2] >> 1) + (p_t
[2] + p_tr
[2] >> 1) >> 1;
874 p
[3] = (p_l
[3] + p_tl
[3] >> 1) + (p_t
[3] + p_tr
[3] >> 1) >> 1;
877 /* PRED_MODE_SELECT */
878 static void inv_predict_11(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
879 const uint8_t *p_t
, const uint8_t *p_tr
)
881 int diff
= (FFABS(p_l
[0] - p_tl
[0]) - FFABS(p_t
[0] - p_tl
[0])) +
882 (FFABS(p_l
[1] - p_tl
[1]) - FFABS(p_t
[1] - p_tl
[1])) +
883 (FFABS(p_l
[2] - p_tl
[2]) - FFABS(p_t
[2] - p_tl
[2])) +
884 (FFABS(p_l
[3] - p_tl
[3]) - FFABS(p_t
[3] - p_tl
[3]));
891 /* PRED_MODE_ADD_SUBTRACT_FULL */
892 static void inv_predict_12(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
893 const uint8_t *p_t
, const uint8_t *p_tr
)
895 p
[0] = av_clip_uint8(p_l
[0] + p_t
[0] - p_tl
[0]);
896 p
[1] = av_clip_uint8(p_l
[1] + p_t
[1] - p_tl
[1]);
897 p
[2] = av_clip_uint8(p_l
[2] + p_t
[2] - p_tl
[2]);
898 p
[3] = av_clip_uint8(p_l
[3] + p_t
[3] - p_tl
[3]);
901 static av_always_inline
uint8_t clamp_add_subtract_half(int a
, int b
, int c
)
904 return av_clip_uint8(d
+ (d
- c
) / 2);
907 /* PRED_MODE_ADD_SUBTRACT_HALF */
908 static void inv_predict_13(uint8_t *p
, const uint8_t *p_l
, const uint8_t *p_tl
,
909 const uint8_t *p_t
, const uint8_t *p_tr
)
911 p
[0] = clamp_add_subtract_half(p_l
[0], p_t
[0], p_tl
[0]);
912 p
[1] = clamp_add_subtract_half(p_l
[1], p_t
[1], p_tl
[1]);
913 p
[2] = clamp_add_subtract_half(p_l
[2], p_t
[2], p_tl
[2]);
914 p
[3] = clamp_add_subtract_half(p_l
[3], p_t
[3], p_tl
[3]);
917 typedef void (*inv_predict_func
)(uint8_t *p
, const uint8_t *p_l
,
918 const uint8_t *p_tl
, const uint8_t *p_t
,
919 const uint8_t *p_tr
);
921 static const inv_predict_func inverse_predict
[14] = {
922 inv_predict_0
, inv_predict_1
, inv_predict_2
, inv_predict_3
,
923 inv_predict_4
, inv_predict_5
, inv_predict_6
, inv_predict_7
,
924 inv_predict_8
, inv_predict_9
, inv_predict_10
, inv_predict_11
,
925 inv_predict_12
, inv_predict_13
,
928 static void inverse_prediction(AVFrame
*frame
, enum PredictionMode m
, int x
, int y
)
930 uint8_t *dec
, *p_l
, *p_tl
, *p_t
, *p_tr
;
933 dec
= GET_PIXEL(frame
, x
, y
);
934 p_l
= GET_PIXEL(frame
, x
- 1, y
);
935 p_tl
= GET_PIXEL(frame
, x
- 1, y
- 1);
936 p_t
= GET_PIXEL(frame
, x
, y
- 1);
937 if (x
== frame
->width
- 1)
938 p_tr
= GET_PIXEL(frame
, 0, y
);
940 p_tr
= GET_PIXEL(frame
, x
+ 1, y
- 1);
942 inverse_predict
[m
](p
, p_l
, p_tl
, p_t
, p_tr
);
950 static int apply_predictor_transform(WebPContext
*s
)
952 ImageContext
*img
= &s
->image
[IMAGE_ROLE_ARGB
];
953 ImageContext
*pimg
= &s
->image
[IMAGE_ROLE_PREDICTOR
];
956 for (y
= 0; y
< img
->frame
->height
; y
++) {
957 for (x
= 0; x
< img
->frame
->width
; x
++) {
958 int tx
= x
>> pimg
->size_reduction
;
959 int ty
= y
>> pimg
->size_reduction
;
960 enum PredictionMode m
= GET_PIXEL_COMP(pimg
->frame
, tx
, ty
, 2);
971 av_log(s
->avctx
, AV_LOG_ERROR
,
972 "invalid predictor mode: %d\n", m
);
973 return AVERROR_INVALIDDATA
;
975 inverse_prediction(img
->frame
, m
, x
, y
);
981 static av_always_inline
uint8_t color_transform_delta(uint8_t color_pred
,
984 return (int)ff_u8_to_s8(color_pred
) * ff_u8_to_s8(color
) >> 5;
987 static int apply_color_transform(WebPContext
*s
)
989 ImageContext
*img
, *cimg
;
993 img
= &s
->image
[IMAGE_ROLE_ARGB
];
994 cimg
= &s
->image
[IMAGE_ROLE_COLOR_TRANSFORM
];
996 for (y
= 0; y
< img
->frame
->height
; y
++) {
997 for (x
= 0; x
< img
->frame
->width
; x
++) {
998 cx
= x
>> cimg
->size_reduction
;
999 cy
= y
>> cimg
->size_reduction
;
1000 cp
= GET_PIXEL(cimg
->frame
, cx
, cy
);
1001 p
= GET_PIXEL(img
->frame
, x
, y
);
1003 p
[1] += color_transform_delta(cp
[3], p
[2]);
1004 p
[3] += color_transform_delta(cp
[2], p
[2]) +
1005 color_transform_delta(cp
[1], p
[1]);
1011 static int apply_subtract_green_transform(WebPContext
*s
)
1014 ImageContext
*img
= &s
->image
[IMAGE_ROLE_ARGB
];
1016 for (y
= 0; y
< img
->frame
->height
; y
++) {
1017 for (x
= 0; x
< img
->frame
->width
; x
++) {
1018 uint8_t *p
= GET_PIXEL(img
->frame
, x
, y
);
1026 static int apply_color_indexing_transform(WebPContext
*s
)
1033 img
= &s
->image
[IMAGE_ROLE_ARGB
];
1034 pal
= &s
->image
[IMAGE_ROLE_COLOR_INDEXING
];
1036 if (pal
->size_reduction
> 0) {
1039 int pixel_bits
= 8 >> pal
->size_reduction
;
1041 line
= av_malloc(img
->frame
->linesize
[0]);
1043 return AVERROR(ENOMEM
);
1045 for (y
= 0; y
< img
->frame
->height
; y
++) {
1046 p
= GET_PIXEL(img
->frame
, 0, y
);
1047 memcpy(line
, p
, img
->frame
->linesize
[0]);
1048 init_get_bits(&gb_g
, line
, img
->frame
->linesize
[0] * 8);
1049 skip_bits(&gb_g
, 16);
1051 for (x
= 0; x
< img
->frame
->width
; x
++) {
1052 p
= GET_PIXEL(img
->frame
, x
, y
);
1053 p
[2] = get_bits(&gb_g
, pixel_bits
);
1055 if (i
== 1 << pal
->size_reduction
) {
1056 skip_bits(&gb_g
, 24);
1064 // switch to local palette if it's worth initializing it
1065 if (img
->frame
->height
* img
->frame
->width
> 300) {
1066 uint8_t palette
[256 * 4];
1067 const int size
= pal
->frame
->width
* 4;
1068 av_assert0(size
<= 1024U);
1069 memcpy(palette
, GET_PIXEL(pal
->frame
, 0, 0), size
); // copy palette
1070 // set extra entries to transparent black
1071 memset(palette
+ size
, 0, 256 * 4 - size
);
1072 for (y
= 0; y
< img
->frame
->height
; y
++) {
1073 for (x
= 0; x
< img
->frame
->width
; x
++) {
1074 p
= GET_PIXEL(img
->frame
, x
, y
);
1076 AV_COPY32(p
, &palette
[i
* 4]);
1080 for (y
= 0; y
< img
->frame
->height
; y
++) {
1081 for (x
= 0; x
< img
->frame
->width
; x
++) {
1082 p
= GET_PIXEL(img
->frame
, x
, y
);
1084 if (i
>= pal
->frame
->width
) {
1085 AV_WB32(p
, 0x00000000);
1087 const uint8_t *pi
= GET_PIXEL(pal
->frame
, i
, 0);
1097 static int vp8_lossless_decode_frame(AVCodecContext
*avctx
, AVFrame
*p
,
1098 int *got_frame
, uint8_t *data_start
,
1099 unsigned int data_size
, int is_alpha_chunk
)
1101 WebPContext
*s
= avctx
->priv_data
;
1104 if (!is_alpha_chunk
) {
1106 avctx
->pix_fmt
= AV_PIX_FMT_ARGB
;
1109 ret
= init_get_bits(&s
->gb
, data_start
, data_size
* 8);
1113 if (!is_alpha_chunk
) {
1114 if (get_bits(&s
->gb
, 8) != 0x2F) {
1115 av_log(avctx
, AV_LOG_ERROR
, "Invalid WebP Lossless signature\n");
1116 return AVERROR_INVALIDDATA
;
1119 w
= get_bits(&s
->gb
, 14) + 1;
1120 h
= get_bits(&s
->gb
, 14) + 1;
1121 if (s
->width
&& s
->width
!= w
) {
1122 av_log(avctx
, AV_LOG_WARNING
, "Width mismatch. %d != %d\n",
1126 if (s
->height
&& s
->height
!= h
) {
1127 av_log(avctx
, AV_LOG_WARNING
, "Height mismatch. %d != %d\n",
1132 ret
= ff_set_dimensions(avctx
, s
->width
, s
->height
);
1136 s
->has_alpha
= get_bits1(&s
->gb
);
1138 if (get_bits(&s
->gb
, 3) != 0x0) {
1139 av_log(avctx
, AV_LOG_ERROR
, "Invalid WebP Lossless version\n");
1140 return AVERROR_INVALIDDATA
;
1143 if (!s
->width
|| !s
->height
)
1149 /* parse transformations */
1150 s
->nb_transforms
= 0;
1151 s
->reduced_width
= 0;
1152 while (get_bits1(&s
->gb
)) {
1153 enum TransformType transform
= get_bits(&s
->gb
, 2);
1154 s
->transforms
[s
->nb_transforms
++] = transform
;
1155 switch (transform
) {
1156 case PREDICTOR_TRANSFORM
:
1157 ret
= parse_transform_predictor(s
);
1159 case COLOR_TRANSFORM
:
1160 ret
= parse_transform_color(s
);
1162 case COLOR_INDEXING_TRANSFORM
:
1163 ret
= parse_transform_color_indexing(s
);
1167 goto free_and_return
;
1170 /* decode primary image */
1171 s
->image
[IMAGE_ROLE_ARGB
].frame
= p
;
1173 s
->image
[IMAGE_ROLE_ARGB
].is_alpha_primary
= 1;
1174 ret
= decode_entropy_coded_image(s
, IMAGE_ROLE_ARGB
, w
, h
);
1176 goto free_and_return
;
1178 /* apply transformations */
1179 for (i
= s
->nb_transforms
- 1; i
>= 0; i
--) {
1180 switch (s
->transforms
[i
]) {
1181 case PREDICTOR_TRANSFORM
:
1182 ret
= apply_predictor_transform(s
);
1184 case COLOR_TRANSFORM
:
1185 ret
= apply_color_transform(s
);
1187 case SUBTRACT_GREEN
:
1188 ret
= apply_subtract_green_transform(s
);
1190 case COLOR_INDEXING_TRANSFORM
:
1191 ret
= apply_color_indexing_transform(s
);
1195 goto free_and_return
;
1199 p
->pict_type
= AV_PICTURE_TYPE_I
;
1204 for (i
= 0; i
< IMAGE_ROLE_NB
; i
++)
1205 image_ctx_free(&s
->image
[i
]);
1210 static void alpha_inverse_prediction(AVFrame
*frame
, enum AlphaFilter m
)
1215 ls
= frame
->linesize
[3];
1217 /* filter first row using horizontal filter */
1218 dec
= frame
->data
[3] + 1;
1219 for (x
= 1; x
< frame
->width
; x
++, dec
++)
1222 /* filter first column using vertical filter */
1223 dec
= frame
->data
[3] + ls
;
1224 for (y
= 1; y
< frame
->height
; y
++, dec
+= ls
)
1225 *dec
+= *(dec
- ls
);
1227 /* filter the rest using the specified filter */
1229 case ALPHA_FILTER_HORIZONTAL
:
1230 for (y
= 1; y
< frame
->height
; y
++) {
1231 dec
= frame
->data
[3] + y
* ls
+ 1;
1232 for (x
= 1; x
< frame
->width
; x
++, dec
++)
1236 case ALPHA_FILTER_VERTICAL
:
1237 for (y
= 1; y
< frame
->height
; y
++) {
1238 dec
= frame
->data
[3] + y
* ls
+ 1;
1239 for (x
= 1; x
< frame
->width
; x
++, dec
++)
1240 *dec
+= *(dec
- ls
);
1243 case ALPHA_FILTER_GRADIENT
:
1244 for (y
= 1; y
< frame
->height
; y
++) {
1245 dec
= frame
->data
[3] + y
* ls
+ 1;
1246 for (x
= 1; x
< frame
->width
; x
++, dec
++)
1247 dec
[0] += av_clip_uint8(*(dec
- 1) + *(dec
- ls
) - *(dec
- ls
- 1));
1253 static int vp8_lossy_decode_alpha(AVCodecContext
*avctx
, AVFrame
*p
,
1254 uint8_t *data_start
,
1255 unsigned int data_size
)
1257 WebPContext
*s
= avctx
->priv_data
;
1260 if (s
->alpha_compression
== ALPHA_COMPRESSION_NONE
) {
1263 bytestream2_init(&gb
, data_start
, data_size
);
1264 for (y
= 0; y
< s
->height
; y
++)
1265 bytestream2_get_buffer(&gb
, p
->data
[3] + p
->linesize
[3] * y
,
1267 } else if (s
->alpha_compression
== ALPHA_COMPRESSION_VP8L
) {
1269 int alpha_got_frame
= 0;
1271 s
->alpha_frame
= av_frame_alloc();
1272 if (!s
->alpha_frame
)
1273 return AVERROR(ENOMEM
);
1275 ret
= vp8_lossless_decode_frame(avctx
, s
->alpha_frame
, &alpha_got_frame
,
1276 data_start
, data_size
, 1);
1278 av_frame_free(&s
->alpha_frame
);
1281 if (!alpha_got_frame
) {
1282 av_frame_free(&s
->alpha_frame
);
1283 return AVERROR_INVALIDDATA
;
1286 /* copy green component of alpha image to alpha plane of primary image */
1287 for (y
= 0; y
< s
->height
; y
++) {
1288 ap
= GET_PIXEL(s
->alpha_frame
, 0, y
) + 2;
1289 pp
= p
->data
[3] + p
->linesize
[3] * y
;
1290 for (x
= 0; x
< s
->width
; x
++) {
1296 av_frame_free(&s
->alpha_frame
);
1299 /* apply alpha filtering */
1300 if (s
->alpha_filter
)
1301 alpha_inverse_prediction(p
, s
->alpha_filter
);
1306 static int vp8_lossy_decode_frame(AVCodecContext
*avctx
, AVFrame
*p
,
1307 int *got_frame
, uint8_t *data_start
,
1308 unsigned int data_size
)
1310 WebPContext
*s
= avctx
->priv_data
;
1314 if (!s
->initialized
) {
1315 ff_vp8_decode_init(avctx
);
1318 avctx
->pix_fmt
= AV_PIX_FMT_YUVA420P
;
1322 if (data_size
> INT_MAX
) {
1323 av_log(avctx
, AV_LOG_ERROR
, "unsupported chunk size\n");
1324 return AVERROR_PATCHWELCOME
;
1327 av_init_packet(&pkt
);
1328 pkt
.data
= data_start
;
1329 pkt
.size
= data_size
;
1331 ret
= ff_vp8_decode_frame(avctx
, p
, got_frame
, &pkt
);
1333 ret
= vp8_lossy_decode_alpha(avctx
, p
, s
->alpha_data
,
1334 s
->alpha_data_size
);
1341 static int webp_decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
1344 AVFrame
* const p
= data
;
1345 WebPContext
*s
= avctx
->priv_data
;
1348 uint32_t chunk_type
, chunk_size
;
1357 bytestream2_init(&gb
, avpkt
->data
, avpkt
->size
);
1359 if (bytestream2_get_bytes_left(&gb
) < 12)
1360 return AVERROR_INVALIDDATA
;
1362 if (bytestream2_get_le32(&gb
) != MKTAG('R', 'I', 'F', 'F')) {
1363 av_log(avctx
, AV_LOG_ERROR
, "missing RIFF tag\n");
1364 return AVERROR_INVALIDDATA
;
1367 chunk_size
= bytestream2_get_le32(&gb
);
1368 if (bytestream2_get_bytes_left(&gb
) < chunk_size
)
1369 return AVERROR_INVALIDDATA
;
1371 if (bytestream2_get_le32(&gb
) != MKTAG('W', 'E', 'B', 'P')) {
1372 av_log(avctx
, AV_LOG_ERROR
, "missing WEBP tag\n");
1373 return AVERROR_INVALIDDATA
;
1376 av_dict_free(&s
->exif_metadata
);
1377 while (bytestream2_get_bytes_left(&gb
) > 0) {
1378 char chunk_str
[5] = { 0 };
1380 chunk_type
= bytestream2_get_le32(&gb
);
1381 chunk_size
= bytestream2_get_le32(&gb
);
1382 if (chunk_size
== UINT32_MAX
)
1383 return AVERROR_INVALIDDATA
;
1384 chunk_size
+= chunk_size
& 1;
1386 if (bytestream2_get_bytes_left(&gb
) < chunk_size
)
1387 return AVERROR_INVALIDDATA
;
1389 switch (chunk_type
) {
1390 case MKTAG('V', 'P', '8', ' '):
1392 ret
= vp8_lossy_decode_frame(avctx
, p
, got_frame
,
1393 avpkt
->data
+ bytestream2_tell(&gb
),
1398 bytestream2_skip(&gb
, chunk_size
);
1400 case MKTAG('V', 'P', '8', 'L'):
1402 ret
= vp8_lossless_decode_frame(avctx
, p
, got_frame
,
1403 avpkt
->data
+ bytestream2_tell(&gb
),
1408 bytestream2_skip(&gb
, chunk_size
);
1410 case MKTAG('V', 'P', '8', 'X'):
1411 vp8x_flags
= bytestream2_get_byte(&gb
);
1412 bytestream2_skip(&gb
, 3);
1413 s
->width
= bytestream2_get_le24(&gb
) + 1;
1414 s
->height
= bytestream2_get_le24(&gb
) + 1;
1415 ret
= av_image_check_size(s
->width
, s
->height
, 0, avctx
);
1419 case MKTAG('A', 'L', 'P', 'H'): {
1420 int alpha_header
, filter_m
, compression
;
1422 if (!(vp8x_flags
& VP8X_FLAG_ALPHA
)) {
1423 av_log(avctx
, AV_LOG_WARNING
,
1424 "ALPHA chunk present, but alpha bit not set in the "
1427 if (chunk_size
== 0) {
1428 av_log(avctx
, AV_LOG_ERROR
, "invalid ALPHA chunk size\n");
1429 return AVERROR_INVALIDDATA
;
1431 alpha_header
= bytestream2_get_byte(&gb
);
1432 s
->alpha_data
= avpkt
->data
+ bytestream2_tell(&gb
);
1433 s
->alpha_data_size
= chunk_size
- 1;
1434 bytestream2_skip(&gb
, s
->alpha_data_size
);
1436 filter_m
= (alpha_header
>> 2) & 0x03;
1437 compression
= alpha_header
& 0x03;
1439 if (compression
> ALPHA_COMPRESSION_VP8L
) {
1440 av_log(avctx
, AV_LOG_VERBOSE
,
1441 "skipping unsupported ALPHA chunk\n");
1444 s
->alpha_compression
= compression
;
1445 s
->alpha_filter
= filter_m
;
1450 case MKTAG('E', 'X', 'I', 'F'): {
1451 int le
, ifd_offset
, exif_offset
= bytestream2_tell(&gb
);
1452 GetByteContext exif_gb
;
1455 av_log(avctx
, AV_LOG_VERBOSE
, "Ignoring extra EXIF chunk\n");
1458 if (!(vp8x_flags
& VP8X_FLAG_EXIF_METADATA
))
1459 av_log(avctx
, AV_LOG_WARNING
,
1460 "EXIF chunk present, but Exif bit not set in the "
1464 bytestream2_init(&exif_gb
, avpkt
->data
+ exif_offset
,
1465 avpkt
->size
- exif_offset
);
1466 if (ff_tdecode_header(&exif_gb
, &le
, &ifd_offset
) < 0) {
1467 av_log(avctx
, AV_LOG_ERROR
, "invalid TIFF header "
1472 bytestream2_seek(&exif_gb
, ifd_offset
, SEEK_SET
);
1473 if (avpriv_exif_decode_ifd(avctx
, &exif_gb
, le
, 0, &s
->exif_metadata
) < 0) {
1474 av_log(avctx
, AV_LOG_ERROR
, "error decoding Exif data\n");
1478 av_dict_copy(avpriv_frame_get_metadatap(data
), s
->exif_metadata
, 0);
1481 av_dict_free(&s
->exif_metadata
);
1482 bytestream2_skip(&gb
, chunk_size
);
1485 case MKTAG('I', 'C', 'C', 'P'):
1486 case MKTAG('A', 'N', 'I', 'M'):
1487 case MKTAG('A', 'N', 'M', 'F'):
1488 case MKTAG('X', 'M', 'P', ' '):
1489 AV_WL32(chunk_str
, chunk_type
);
1490 av_log(avctx
, AV_LOG_VERBOSE
, "skipping unsupported chunk: %s\n",
1492 bytestream2_skip(&gb
, chunk_size
);
1495 AV_WL32(chunk_str
, chunk_type
);
1496 av_log(avctx
, AV_LOG_VERBOSE
, "skipping unknown chunk: %s\n",
1498 bytestream2_skip(&gb
, chunk_size
);
1504 av_log(avctx
, AV_LOG_ERROR
, "image data not found\n");
1505 return AVERROR_INVALIDDATA
;
1511 static av_cold
int webp_decode_close(AVCodecContext
*avctx
)
1513 WebPContext
*s
= avctx
->priv_data
;
1516 return ff_vp8_decode_free(avctx
);
1521 AVCodec ff_webp_decoder
= {
1523 .long_name
= NULL_IF_CONFIG_SMALL("WebP image"),
1524 .type
= AVMEDIA_TYPE_VIDEO
,
1525 .id
= AV_CODEC_ID_WEBP
,
1526 .priv_data_size
= sizeof(WebPContext
),
1527 .decode
= webp_decode_frame
,
1528 .close
= webp_decode_close
,
1529 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,