GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/webp.c Lines: 611 799 76.5 %
Date: 2021-04-18 10:33:33 Branches: 259 393 65.9 %

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
45
#define BITSTREAM_READER_LE
46
#include "avcodec.h"
47
#include "bytestream.h"
48
#include "exif.h"
49
#include "get_bits.h"
50
#include "internal.h"
51
#include "thread.h"
52
#include "vp8.h"
53
54
#define VP8X_FLAG_ANIMATION             0x02
55
#define VP8X_FLAG_XMP_METADATA          0x04
56
#define VP8X_FLAG_EXIF_METADATA         0x08
57
#define VP8X_FLAG_ALPHA                 0x10
58
#define VP8X_FLAG_ICC                   0x20
59
60
#define MAX_PALETTE_SIZE                256
61
#define MAX_CACHE_BITS                  11
62
#define NUM_CODE_LENGTH_CODES           19
63
#define HUFFMAN_CODES_PER_META_CODE     5
64
#define NUM_LITERAL_CODES               256
65
#define NUM_LENGTH_CODES                24
66
#define NUM_DISTANCE_CODES              40
67
#define NUM_SHORT_DISTANCES             120
68
#define MAX_HUFFMAN_CODE_LENGTH         15
69
70
static const uint16_t alphabet_sizes[HUFFMAN_CODES_PER_META_CODE] = {
71
    NUM_LITERAL_CODES + NUM_LENGTH_CODES,
72
    NUM_LITERAL_CODES, NUM_LITERAL_CODES, NUM_LITERAL_CODES,
73
    NUM_DISTANCE_CODES
74
};
75
76
static const uint8_t code_length_code_order[NUM_CODE_LENGTH_CODES] = {
77
    17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
78
};
79
80
static const int8_t lz77_distance_offsets[NUM_SHORT_DISTANCES][2] = {
81
    {  0, 1 }, {  1, 0 }, {  1, 1 }, { -1, 1 }, {  0, 2 }, {  2, 0 }, {  1, 2 }, { -1, 2 },
82
    {  2, 1 }, { -2, 1 }, {  2, 2 }, { -2, 2 }, {  0, 3 }, {  3, 0 }, {  1, 3 }, { -1, 3 },
83
    {  3, 1 }, { -3, 1 }, {  2, 3 }, { -2, 3 }, {  3, 2 }, { -3, 2 }, {  0, 4 }, {  4, 0 },
84
    {  1, 4 }, { -1, 4 }, {  4, 1 }, { -4, 1 }, {  3, 3 }, { -3, 3 }, {  2, 4 }, { -2, 4 },
85
    {  4, 2 }, { -4, 2 }, {  0, 5 }, {  3, 4 }, { -3, 4 }, {  4, 3 }, { -4, 3 }, {  5, 0 },
86
    {  1, 5 }, { -1, 5 }, {  5, 1 }, { -5, 1 }, {  2, 5 }, { -2, 5 }, {  5, 2 }, { -5, 2 },
87
    {  4, 4 }, { -4, 4 }, {  3, 5 }, { -3, 5 }, {  5, 3 }, { -5, 3 }, {  0, 6 }, {  6, 0 },
88
    {  1, 6 }, { -1, 6 }, {  6, 1 }, { -6, 1 }, {  2, 6 }, { -2, 6 }, {  6, 2 }, { -6, 2 },
89
    {  4, 5 }, { -4, 5 }, {  5, 4 }, { -5, 4 }, {  3, 6 }, { -3, 6 }, {  6, 3 }, { -6, 3 },
90
    {  0, 7 }, {  7, 0 }, {  1, 7 }, { -1, 7 }, {  5, 5 }, { -5, 5 }, {  7, 1 }, { -7, 1 },
91
    {  4, 6 }, { -4, 6 }, {  6, 4 }, { -6, 4 }, {  2, 7 }, { -2, 7 }, {  7, 2 }, { -7, 2 },
92
    {  3, 7 }, { -3, 7 }, {  7, 3 }, { -7, 3 }, {  5, 6 }, { -5, 6 }, {  6, 5 }, { -6, 5 },
93
    {  8, 0 }, {  4, 7 }, { -4, 7 }, {  7, 4 }, { -7, 4 }, {  8, 1 }, {  8, 2 }, {  6, 6 },
94
    { -6, 6 }, {  8, 3 }, {  5, 7 }, { -5, 7 }, {  7, 5 }, { -7, 5 }, {  8, 4 }, {  6, 7 },
95
    { -6, 7 }, {  7, 6 }, { -7, 6 }, {  8, 5 }, {  7, 7 }, { -7, 7 }, {  8, 6 }, {  8, 7 }
96
};
97
98
enum AlphaCompression {
99
    ALPHA_COMPRESSION_NONE,
100
    ALPHA_COMPRESSION_VP8L,
101
};
102
103
enum AlphaFilter {
104
    ALPHA_FILTER_NONE,
105
    ALPHA_FILTER_HORIZONTAL,
106
    ALPHA_FILTER_VERTICAL,
107
    ALPHA_FILTER_GRADIENT,
108
};
109
110
enum TransformType {
111
    PREDICTOR_TRANSFORM      = 0,
112
    COLOR_TRANSFORM          = 1,
113
    SUBTRACT_GREEN           = 2,
114
    COLOR_INDEXING_TRANSFORM = 3,
115
};
116
117
enum PredictionMode {
118
    PRED_MODE_BLACK,
119
    PRED_MODE_L,
120
    PRED_MODE_T,
121
    PRED_MODE_TR,
122
    PRED_MODE_TL,
123
    PRED_MODE_AVG_T_AVG_L_TR,
124
    PRED_MODE_AVG_L_TL,
125
    PRED_MODE_AVG_L_T,
126
    PRED_MODE_AVG_TL_T,
127
    PRED_MODE_AVG_T_TR,
128
    PRED_MODE_AVG_AVG_L_TL_AVG_T_TR,
129
    PRED_MODE_SELECT,
130
    PRED_MODE_ADD_SUBTRACT_FULL,
131
    PRED_MODE_ADD_SUBTRACT_HALF,
132
};
133
134
enum HuffmanIndex {
135
    HUFF_IDX_GREEN = 0,
136
    HUFF_IDX_RED   = 1,
137
    HUFF_IDX_BLUE  = 2,
138
    HUFF_IDX_ALPHA = 3,
139
    HUFF_IDX_DIST  = 4
140
};
141
142
/* The structure of WebP lossless is an optional series of transformation data,
143
 * followed by the primary image. The primary image also optionally contains
144
 * an entropy group mapping if there are multiple entropy groups. There is a
145
 * basic image type called an "entropy coded image" that is used for all of
146
 * these. The type of each entropy coded image is referred to by the
147
 * specification as its role. */
148
enum ImageRole {
149
    /* Primary Image: Stores the actual pixels of the image. */
150
    IMAGE_ROLE_ARGB,
151
152
    /* Entropy Image: Defines which Huffman group to use for different areas of
153
     *                the primary image. */
154
    IMAGE_ROLE_ENTROPY,
155
156
    /* Predictors: Defines which predictor type to use for different areas of
157
     *             the primary image. */
158
    IMAGE_ROLE_PREDICTOR,
159
160
    /* Color Transform Data: Defines the color transformation for different
161
     *                       areas of the primary image. */
162
    IMAGE_ROLE_COLOR_TRANSFORM,
163
164
    /* Color Index: Stored as an image of height == 1. */
165
    IMAGE_ROLE_COLOR_INDEXING,
166
167
    IMAGE_ROLE_NB,
168
};
169
170
typedef struct HuffReader {
171
    VLC vlc;                            /* Huffman decoder context */
172
    int simple;                         /* whether to use simple mode */
173
    int nb_symbols;                     /* number of coded symbols */
174
    uint16_t simple_symbols[2];         /* symbols for simple mode */
175
} HuffReader;
176
177
typedef struct ImageContext {
178
    enum ImageRole role;                /* role of this image */
179
    AVFrame *frame;                     /* AVFrame for data */
180
    int color_cache_bits;               /* color cache size, log2 */
181
    uint32_t *color_cache;              /* color cache data */
182
    int nb_huffman_groups;              /* number of huffman groups */
183
    HuffReader *huffman_groups;         /* reader for each huffman group */
184
    int size_reduction;                 /* relative size compared to primary image, log2 */
185
    int is_alpha_primary;
186
} ImageContext;
187
188
typedef struct WebPContext {
189
    VP8Context v;                       /* VP8 Context used for lossy decoding */
190
    GetBitContext gb;                   /* bitstream reader for main image chunk */
191
    AVFrame *alpha_frame;               /* AVFrame for alpha data decompressed from VP8L */
192
    AVPacket *pkt;                      /* AVPacket to be passed to the underlying VP8 decoder */
193
    AVCodecContext *avctx;              /* parent AVCodecContext */
194
    int initialized;                    /* set once the VP8 context is initialized */
195
    int has_alpha;                      /* has a separate alpha chunk */
196
    enum AlphaCompression alpha_compression; /* compression type for alpha chunk */
197
    enum AlphaFilter alpha_filter;      /* filtering method for alpha chunk */
198
    uint8_t *alpha_data;                /* alpha chunk data */
199
    int alpha_data_size;                /* alpha chunk data size */
200
    int has_exif;                       /* set after an EXIF chunk has been processed */
201
    int has_iccp;                       /* set after an ICCP chunk has been processed */
202
    int width;                          /* image width */
203
    int height;                         /* image height */
204
    int lossless;                       /* indicates lossless or lossy */
205
206
    int nb_transforms;                  /* number of transforms */
207
    enum TransformType transforms[4];   /* transformations used in the image, in order */
208
    int reduced_width;                  /* reduced width for index image, if applicable */
209
    int nb_huffman_groups;              /* number of huffman groups in the primary image */
210
    ImageContext image[IMAGE_ROLE_NB];  /* image context for each role */
211
} WebPContext;
212
213
#define GET_PIXEL(frame, x, y) \
214
    ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
215
216
#define GET_PIXEL_COMP(frame, x, y, c) \
217
    (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
218
219
50
static void image_ctx_free(ImageContext *img)
220
{
221
    int i, j;
222
223
50
    av_free(img->color_cache);
224

50
    if (img->role != IMAGE_ROLE_ARGB && !img->is_alpha_primary)
225
18
        av_frame_free(&img->frame);
226
50
    if (img->huffman_groups) {
227
64
        for (i = 0; i < img->nb_huffman_groups; i++) {
228
216
            for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++)
229
180
                ff_free_vlc(&img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE + j].vlc);
230
        }
231
28
        av_free(img->huffman_groups);
232
    }
233
50
    memset(img, 0, sizeof(*img));
234
50
}
235
236
277908
static int huff_reader_get_symbol(HuffReader *r, GetBitContext *gb)
237
{
238
277908
    if (r->simple) {
239
72022
        if (r->nb_symbols == 1)
240
71710
            return r->simple_symbols[0];
241
        else
242
312
            return r->simple_symbols[get_bits1(gb)];
243
    } else
244
205886
        return get_vlc2(gb, r->vlc.table, 8, 2);
245
}
246
247
156
static int huff_reader_build_canonical(HuffReader *r, const uint8_t *code_lengths,
248
                                       int alphabet_size)
249
{
250
156
    int len = 0, sym, code = 0, ret;
251
156
    int max_code_length = 0;
252
    uint16_t *codes;
253
254
    /* special-case 1 symbol since the vlc reader cannot handle it */
255
706
    for (sym = 0; sym < alphabet_size; sym++) {
256
706
        if (code_lengths[sym] > 0) {
257
312
            len++;
258
312
            code = sym;
259
312
            if (len > 1)
260
156
                break;
261
        }
262
    }
263
156
    if (len == 1) {
264
        r->nb_symbols = 1;
265
        r->simple_symbols[0] = code;
266
        r->simple = 1;
267
        return 0;
268
    }
269
270
22470
    for (sym = 0; sym < alphabet_size; sym++)
271
22314
        max_code_length = FFMAX(max_code_length, code_lengths[sym]);
272
273

156
    if (max_code_length == 0 || max_code_length > MAX_HUFFMAN_CODE_LENGTH)
274
        return AVERROR(EINVAL);
275
276
156
    codes = av_malloc_array(alphabet_size, sizeof(*codes));
277
156
    if (!codes)
278
        return AVERROR(ENOMEM);
279
280
156
    code = 0;
281
156
    r->nb_symbols = 0;
282
1226
    for (len = 1; len <= max_code_length; len++) {
283
196630
        for (sym = 0; sym < alphabet_size; sym++) {
284
195560
            if (code_lengths[sym] != len)
285
188272
                continue;
286
7288
            codes[sym] = code++;
287
7288
            r->nb_symbols++;
288
        }
289
1070
        code <<= 1;
290
    }
291
156
    if (!r->nb_symbols) {
292
        av_free(codes);
293
        return AVERROR_INVALIDDATA;
294
    }
295
296
156
    ret = init_vlc(&r->vlc, 8, alphabet_size,
297
                   code_lengths, sizeof(*code_lengths), sizeof(*code_lengths),
298
                   codes, sizeof(*codes), sizeof(*codes), INIT_VLC_OUTPUT_LE);
299
156
    if (ret < 0) {
300
        av_free(codes);
301
        return ret;
302
    }
303
156
    r->simple = 0;
304
305
156
    av_free(codes);
306
156
    return 0;
307
}
308
309
102
static void read_huffman_code_simple(WebPContext *s, HuffReader *hc)
310
{
311
102
    hc->nb_symbols = get_bits1(&s->gb) + 1;
312
313
102
    if (get_bits1(&s->gb))
314
14
        hc->simple_symbols[0] = get_bits(&s->gb, 8);
315
    else
316
88
        hc->simple_symbols[0] = get_bits1(&s->gb);
317
318
102
    if (hc->nb_symbols == 2)
319
10
        hc->simple_symbols[1] = get_bits(&s->gb, 8);
320
321
102
    hc->simple = 1;
322
102
}
323
324
78
static int read_huffman_code_normal(WebPContext *s, HuffReader *hc,
325
                                    int alphabet_size)
326
{
327
78
    HuffReader code_len_hc = { { 0 }, 0, 0, { 0 } };
328
    uint8_t *code_lengths;
329
78
    uint8_t code_length_code_lengths[NUM_CODE_LENGTH_CODES] = { 0 };
330
    int i, symbol, max_symbol, prev_code_len, ret;
331
78
    int num_codes = 4 + get_bits(&s->gb, 4);
332
333
    av_assert1(num_codes <= NUM_CODE_LENGTH_CODES);
334
335
1154
    for (i = 0; i < num_codes; i++)
336
1076
        code_length_code_lengths[code_length_code_order[i]] = get_bits(&s->gb, 3);
337
338
78
    ret = huff_reader_build_canonical(&code_len_hc, code_length_code_lengths,
339
                                      NUM_CODE_LENGTH_CODES);
340
78
    if (ret < 0)
341
        return ret;
342
343
78
    code_lengths = av_mallocz(alphabet_size);
344
78
    if (!code_lengths) {
345
        ret = AVERROR(ENOMEM);
346
        goto finish;
347
    }
348
349
78
    if (get_bits1(&s->gb)) {
350
8
        int bits   = 2 + 2 * get_bits(&s->gb, 3);
351
8
        max_symbol = 2 + get_bits(&s->gb, bits);
352
8
        if (max_symbol > alphabet_size) {
353
            av_log(s->avctx, AV_LOG_ERROR, "max symbol %d > alphabet size %d\n",
354
                   max_symbol, alphabet_size);
355
            ret = AVERROR_INVALIDDATA;
356
            goto finish;
357
        }
358
    } else {
359
70
        max_symbol = alphabet_size;
360
    }
361
362
78
    prev_code_len = 8;
363
78
    symbol        = 0;
364
3222
    while (symbol < alphabet_size) {
365
        int code_len;
366
367
3152
        if (!max_symbol--)
368
8
            break;
369
3144
        code_len = huff_reader_get_symbol(&code_len_hc, &s->gb);
370
3144
        if (code_len < 16) {
371
            /* Code length code [0..15] indicates literal code lengths. */
372
1880
            code_lengths[symbol++] = code_len;
373
1880
            if (code_len)
374
1760
                prev_code_len = code_len;
375
        } else {
376
1264
            int repeat = 0, length = 0;
377

1264
            switch (code_len) {
378
868
            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
868
                repeat = 3 + get_bits(&s->gb, 2);
383
868
                length = prev_code_len;
384
868
                break;
385
140
            case 17:
386
                /* Code 17 emits a streak of zeros [3..10], i.e.,
387
                 * 3 + ReadBits(3) times. */
388
140
                repeat = 3 + get_bits(&s->gb, 3);
389
140
                break;
390
256
            case 18:
391
                /* Code 18 emits a streak of zeros of length [11..138], i.e.,
392
                 * 11 + ReadBits(7) times. */
393
256
                repeat = 11 + get_bits(&s->gb, 7);
394
256
                break;
395
            }
396
1264
            if (symbol + repeat > alphabet_size) {
397
                av_log(s->avctx, AV_LOG_ERROR,
398
                       "invalid symbol %d + repeat %d > alphabet size %d\n",
399
                       symbol, repeat, alphabet_size);
400
                ret = AVERROR_INVALIDDATA;
401
                goto finish;
402
            }
403
19354
            while (repeat-- > 0)
404
18090
                code_lengths[symbol++] = length;
405
        }
406
    }
407
408
78
    ret = huff_reader_build_canonical(hc, code_lengths, alphabet_size);
409
410
78
finish:
411
78
    ff_free_vlc(&code_len_hc.vlc);
412
78
    av_free(code_lengths);
413
78
    return ret;
414
}
415
416
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
417
                                      int w, int h);
418
419
#define PARSE_BLOCK_SIZE(w, h) do {                                         \
420
    block_bits = get_bits(&s->gb, 3) + 2;                                   \
421
    blocks_w   = FFALIGN((w), 1 << block_bits) >> block_bits;               \
422
    blocks_h   = FFALIGN((h), 1 << block_bits) >> block_bits;               \
423
} while (0)
424
425
4
static int decode_entropy_image(WebPContext *s)
426
{
427
    ImageContext *img;
428
    int ret, block_bits, width, blocks_w, blocks_h, x, y, max;
429
430
4
    width = s->width;
431
4
    if (s->reduced_width > 0)
432
        width = s->reduced_width;
433
434
4
    PARSE_BLOCK_SIZE(width, s->height);
435
436
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_ENTROPY, blocks_w, blocks_h);
437
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
68
    for (y = 0; y < img->frame->height; y++) {
447
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
4
static int parse_transform_predictor(WebPContext *s)
460
{
461
    int block_bits, blocks_w, blocks_h, ret;
462
463
4
    PARSE_BLOCK_SIZE(s->width, s->height);
464
465
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_PREDICTOR, blocks_w,
466
                                     blocks_h);
467
4
    if (ret < 0)
468
        return ret;
469
470
4
    s->image[IMAGE_ROLE_PREDICTOR].size_reduction = block_bits;
471
472
4
    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->width, s->height);
480
481
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_TRANSFORM, blocks_w,
482
                                     blocks_h);
483
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
6
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
6
    index_size = get_bits(&s->gb, 8) + 1;
498
499
6
    if (index_size <= 2)
500
        width_bits = 3;
501
6
    else if (index_size <= 4)
502
2
        width_bits = 2;
503
4
    else if (index_size <= 16)
504
        width_bits = 1;
505
    else
506
4
        width_bits = 0;
507
508
6
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_INDEXING,
509
                                     index_size, 1);
510
6
    if (ret < 0)
511
        return ret;
512
513
6
    img = &s->image[IMAGE_ROLE_COLOR_INDEXING];
514
6
    img->size_reduction = width_bits;
515
6
    if (width_bits > 0)
516
2
        s->reduced_width = (s->width + ((1 << width_bits) - 1)) >> width_bits;
517
518
    /* color index values are delta-coded */
519
6
    ct  = img->frame->data[0] + 4;
520
1422
    for (x = 4; x < img->frame->width * 4; x++, ct++)
521
1416
        ct[0] += ct[-4];
522
523
6
    return 0;
524
}
525
526
68752
static HuffReader *get_huffman_group(WebPContext *s, ImageContext *img,
527
                                     int x, int y)
528
{
529
68752
    ImageContext *gimg = &s->image[IMAGE_ROLE_ENTROPY];
530
68752
    int group = 0;
531
532
68752
    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
68752
    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
28
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
28
    img       = &s->image[role];
557
28
    img->role = role;
558
559
28
    if (!img->frame) {
560
18
        img->frame = av_frame_alloc();
561
18
        if (!img->frame)
562
            return AVERROR(ENOMEM);
563
    }
564
565
28
    img->frame->format = AV_PIX_FMT_ARGB;
566
28
    img->frame->width  = w;
567
28
    img->frame->height = h;
568
569

36
    if (role == IMAGE_ROLE_ARGB && !img->is_alpha_primary) {
570
8
        ThreadFrame pt = { .f = img->frame };
571
8
        ret = ff_thread_get_buffer(s->avctx, &pt, 0);
572
    } else
573
20
        ret = av_frame_get_buffer(img->frame, 1);
574
28
    if (ret < 0)
575
        return ret;
576
577
28
    if (get_bits1(&s->gb)) {
578
        img->color_cache_bits = get_bits(&s->gb, 4);
579
        if (img->color_cache_bits < 1 || img->color_cache_bits > 11) {
580
            av_log(s->avctx, AV_LOG_ERROR, "invalid color cache bits: %d\n",
581
                   img->color_cache_bits);
582
            return AVERROR_INVALIDDATA;
583
        }
584
        img->color_cache = av_mallocz_array(1 << img->color_cache_bits,
585
                                            sizeof(*img->color_cache));
586
        if (!img->color_cache)
587
            return AVERROR(ENOMEM);
588
    } else {
589
28
        img->color_cache_bits = 0;
590
    }
591
592
28
    img->nb_huffman_groups = 1;
593

28
    if (role == IMAGE_ROLE_ARGB && get_bits1(&s->gb)) {
594
4
        ret = decode_entropy_image(s);
595
4
        if (ret < 0)
596
            return ret;
597
4
        img->nb_huffman_groups = s->nb_huffman_groups;
598
    }
599
28
    img->huffman_groups = av_mallocz_array(img->nb_huffman_groups *
600
                                           HUFFMAN_CODES_PER_META_CODE,
601
                                           sizeof(*img->huffman_groups));
602
28
    if (!img->huffman_groups)
603
        return AVERROR(ENOMEM);
604
605
64
    for (i = 0; i < img->nb_huffman_groups; i++) {
606
36
        hg = &img->huffman_groups[i * HUFFMAN_CODES_PER_META_CODE];
607
216
        for (j = 0; j < HUFFMAN_CODES_PER_META_CODE; j++) {
608
180
            int alphabet_size = alphabet_sizes[j];
609

180
            if (!j && img->color_cache_bits > 0)
610
                alphabet_size += 1 << img->color_cache_bits;
611
612
180
            if (get_bits1(&s->gb)) {
613
102
                read_huffman_code_simple(s, &hg[j]);
614
            } else {
615
78
                ret = read_huffman_code_normal(s, &hg[j], alphabet_size);
616
78
                if (ret < 0)
617
                    return ret;
618
            }
619
        }
620
    }
621
622
28
    width = img->frame->width;
623

28
    if (role == IMAGE_ROLE_ARGB && s->reduced_width > 0)
624
2
        width = s->reduced_width;
625
626
28
    x = 0; y = 0;
627
68780
    while (y < img->frame->height) {
628
        int v;
629
630
68752
        hg = get_huffman_group(s, img, x, y);
631
68752
        v = huff_reader_get_symbol(&hg[HUFF_IDX_GREEN], &s->gb);
632
68752
        if (v < NUM_LITERAL_CODES) {
633
            /* literal pixel values */
634
68630
            uint8_t *p = GET_PIXEL(img->frame, x, y);
635
68630
            p[2] = v;
636
68630
            p[1] = huff_reader_get_symbol(&hg[HUFF_IDX_RED],   &s->gb);
637
68630
            p[3] = huff_reader_get_symbol(&hg[HUFF_IDX_BLUE],  &s->gb);
638
68630
            p[0] = huff_reader_get_symbol(&hg[HUFF_IDX_ALPHA], &s->gb);
639
68630
            if (img->color_cache_bits)
640
                color_cache_put(img, AV_RB32(p));
641
68630
            x++;
642
68630
            if (x == width) {
643
700
                x = 0;
644
700
                y++;
645
            }
646
122
        } else if (v < NUM_LITERAL_CODES + NUM_LENGTH_CODES) {
647
            /* LZ77 backwards mapping */
648
            int prefix_code, length, distance, ref_x, ref_y;
649
650
            /* parse length and distance */
651
122
            prefix_code = v - NUM_LITERAL_CODES;
652
122
            if (prefix_code < 4) {
653
48
                length = prefix_code + 1;
654
            } else {
655
74
                int extra_bits = (prefix_code - 2) >> 1;
656
74
                int offset     = 2 + (prefix_code & 1) << extra_bits;
657
74
                length = offset + get_bits(&s->gb, extra_bits) + 1;
658
            }
659
122
            prefix_code = huff_reader_get_symbol(&hg[HUFF_IDX_DIST], &s->gb);
660
122
            if (prefix_code > 39U) {
661
                av_log(s->avctx, AV_LOG_ERROR,
662
                       "distance prefix code too large: %d\n", prefix_code);
663
                return AVERROR_INVALIDDATA;
664
            }
665
122
            if (prefix_code < 4) {
666
122
                distance = prefix_code + 1;
667
            } else {
668
                int extra_bits = prefix_code - 2 >> 1;
669
                int offset     = 2 + (prefix_code & 1) << extra_bits;
670
                distance = offset + get_bits(&s->gb, extra_bits) + 1;
671
            }
672
673
            /* find reference location */
674
122
            if (distance <= NUM_SHORT_DISTANCES) {
675
122
                int xi = lz77_distance_offsets[distance - 1][0];
676
122
                int yi = lz77_distance_offsets[distance - 1][1];
677
122
                distance = FFMAX(1, xi + yi * width);
678
            } else {
679
                distance -= NUM_SHORT_DISTANCES;
680
            }
681
122
            ref_x = x;
682
122
            ref_y = y;
683
122
            if (distance <= x) {
684
36
                ref_x -= distance;
685
36
                distance = 0;
686
            } else {
687
86
                ref_x = 0;
688
86
                distance -= x;
689
            }
690
144
            while (distance >= width) {
691
22
                ref_y--;
692
22
                distance -= width;
693
            }
694
122
            if (distance > 0) {
695
64
                ref_x = width - distance;
696
64
                ref_y--;
697
            }
698
122
            ref_x = FFMAX(0, ref_x);
699
122
            ref_y = FFMAX(0, ref_y);
700
701
            /* copy pixels
702
             * source and dest regions can overlap and wrap lines, so just
703
             * copy per-pixel */
704
886
            for (i = 0; i < length; i++) {
705
770
                uint8_t *p_ref = GET_PIXEL(img->frame, ref_x, ref_y);
706
770
                uint8_t *p     = GET_PIXEL(img->frame,     x,     y);
707
708
770
                AV_COPY32(p, p_ref);
709
770
                if (img->color_cache_bits)
710
                    color_cache_put(img, AV_RB32(p));
711
770
                x++;
712
770
                ref_x++;
713
770
                if (x == width) {
714
58
                    x = 0;
715
58
                    y++;
716
                }
717
770
                if (ref_x == width) {
718
58
                    ref_x = 0;
719
58
                    ref_y++;
720
                }
721

770
                if (y == img->frame->height || ref_y == img->frame->height)
722
                    break;
723
            }
724
        } else {
725
            /* read from color cache */
726
            uint8_t *p = GET_PIXEL(img->frame, x, y);
727
            int cache_idx = v - (NUM_LITERAL_CODES + NUM_LENGTH_CODES);
728
729
            if (!img->color_cache_bits) {
730
                av_log(s->avctx, AV_LOG_ERROR, "color cache not found\n");
731
                return AVERROR_INVALIDDATA;
732
            }
733
            if (cache_idx >= 1 << img->color_cache_bits) {
734
                av_log(s->avctx, AV_LOG_ERROR,
735
                       "color cache index out-of-bounds\n");
736
                return AVERROR_INVALIDDATA;
737
            }
738
            AV_WB32(p, img->color_cache[cache_idx]);
739
            x++;
740
            if (x == width) {
741
                x = 0;
742
                y++;
743
            }
744
        }
745
    }
746
747
28
    return 0;
748
}
749
750
/* PRED_MODE_BLACK */
751
4
static void inv_predict_0(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
752
                          const uint8_t *p_t, const uint8_t *p_tr)
753
{
754
4
    AV_WB32(p, 0xFF000000);
755
4
}
756
757
/* PRED_MODE_L */
758
5276
static void inv_predict_1(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
759
                          const uint8_t *p_t, const uint8_t *p_tr)
760
{
761
5276
    AV_COPY32(p, p_l);
762
5276
}
763
764
/* PRED_MODE_T */
765
20764
static void inv_predict_2(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
766
                          const uint8_t *p_t, const uint8_t *p_tr)
767
{
768
20764
    AV_COPY32(p, p_t);
769
20764
}
770
771
/* PRED_MODE_TR */
772
6336
static void inv_predict_3(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
773
                          const uint8_t *p_t, const uint8_t *p_tr)
774
{
775
6336
    AV_COPY32(p, p_tr);
776
6336
}
777
778
/* PRED_MODE_TL */
779
1248
static void inv_predict_4(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
780
                          const uint8_t *p_t, const uint8_t *p_tr)
781
{
782
1248
    AV_COPY32(p, p_tl);
783
1248
}
784
785
/* PRED_MODE_AVG_T_AVG_L_TR */
786
4832
static void inv_predict_5(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
787
                          const uint8_t *p_t, const uint8_t *p_tr)
788
{
789
4832
    p[0] = p_t[0] + (p_l[0] + p_tr[0] >> 1) >> 1;
790
4832
    p[1] = p_t[1] + (p_l[1] + p_tr[1] >> 1) >> 1;
791
4832
    p[2] = p_t[2] + (p_l[2] + p_tr[2] >> 1) >> 1;
792
4832
    p[3] = p_t[3] + (p_l[3] + p_tr[3] >> 1) >> 1;
793
4832
}
794
795
/* PRED_MODE_AVG_L_TL */
796
768
static void inv_predict_6(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
797
                          const uint8_t *p_t, const uint8_t *p_tr)
798
{
799
768
    p[0] = p_l[0] + p_tl[0] >> 1;
800
768
    p[1] = p_l[1] + p_tl[1] >> 1;
801
768
    p[2] = p_l[2] + p_tl[2] >> 1;
802
768
    p[3] = p_l[3] + p_tl[3] >> 1;
803
768
}
804
805
/* PRED_MODE_AVG_L_T */
806
3072
static void inv_predict_7(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
807
                          const uint8_t *p_t, const uint8_t *p_tr)
808
{
809
3072
    p[0] = p_l[0] + p_t[0] >> 1;
810
3072
    p[1] = p_l[1] + p_t[1] >> 1;
811
3072
    p[2] = p_l[2] + p_t[2] >> 1;
812
3072
    p[3] = p_l[3] + p_t[3] >> 1;
813
3072
}
814
815
/* PRED_MODE_AVG_TL_T */
816
4512
static void inv_predict_8(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
817
                          const uint8_t *p_t, const uint8_t *p_tr)
818
{
819
4512
    p[0] = p_tl[0] + p_t[0] >> 1;
820
4512
    p[1] = p_tl[1] + p_t[1] >> 1;
821
4512
    p[2] = p_tl[2] + p_t[2] >> 1;
822
4512
    p[3] = p_tl[3] + p_t[3] >> 1;
823
4512
}
824
825
/* PRED_MODE_AVG_T_TR */
826
11488
static void inv_predict_9(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
827
                          const uint8_t *p_t, const uint8_t *p_tr)
828
{
829
11488
    p[0] = p_t[0] + p_tr[0] >> 1;
830
11488
    p[1] = p_t[1] + p_tr[1] >> 1;
831
11488
    p[2] = p_t[2] + p_tr[2] >> 1;
832
11488
    p[3] = p_t[3] + p_tr[3] >> 1;
833
11488
}
834
835
/* PRED_MODE_AVG_AVG_L_TL_AVG_T_TR */
836
3236
static void inv_predict_10(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
837
                           const uint8_t *p_t, const uint8_t *p_tr)
838
{
839
3236
    p[0] = (p_l[0] + p_tl[0] >> 1) + (p_t[0] + p_tr[0] >> 1) >> 1;
840
3236
    p[1] = (p_l[1] + p_tl[1] >> 1) + (p_t[1] + p_tr[1] >> 1) >> 1;
841
3236
    p[2] = (p_l[2] + p_tl[2] >> 1) + (p_t[2] + p_tr[2] >> 1) >> 1;
842
3236
    p[3] = (p_l[3] + p_tl[3] >> 1) + (p_t[3] + p_tr[3] >> 1) >> 1;
843
3236
}
844
845
/* PRED_MODE_SELECT */
846
3488
static void inv_predict_11(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
847
                           const uint8_t *p_t, const uint8_t *p_tr)
848
{
849
3488
    int diff = (FFABS(p_l[0] - p_tl[0]) - FFABS(p_t[0] - p_tl[0])) +
850
3488
               (FFABS(p_l[1] - p_tl[1]) - FFABS(p_t[1] - p_tl[1])) +
851
3488
               (FFABS(p_l[2] - p_tl[2]) - FFABS(p_t[2] - p_tl[2])) +
852
3488
               (FFABS(p_l[3] - p_tl[3]) - FFABS(p_t[3] - p_tl[3]));
853
3488
    if (diff <= 0)
854
2296
        AV_COPY32(p, p_t);
855
    else
856
1192
        AV_COPY32(p, p_l);
857
3488
}
858
859
/* PRED_MODE_ADD_SUBTRACT_FULL */
860
static void inv_predict_12(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
861
                           const uint8_t *p_t, const uint8_t *p_tr)
862
{
863
    p[0] = av_clip_uint8(p_l[0] + p_t[0] - p_tl[0]);
864
    p[1] = av_clip_uint8(p_l[1] + p_t[1] - p_tl[1]);
865
    p[2] = av_clip_uint8(p_l[2] + p_t[2] - p_tl[2]);
866
    p[3] = av_clip_uint8(p_l[3] + p_t[3] - p_tl[3]);
867
}
868
869
2048
static av_always_inline uint8_t clamp_add_subtract_half(int a, int b, int c)
870
{
871
2048
    int d = a + b >> 1;
872
2048
    return av_clip_uint8(d + (d - c) / 2);
873
}
874
875
/* PRED_MODE_ADD_SUBTRACT_HALF */
876
512
static void inv_predict_13(uint8_t *p, const uint8_t *p_l, const uint8_t *p_tl,
877
                           const uint8_t *p_t, const uint8_t *p_tr)
878
{
879
512
    p[0] = clamp_add_subtract_half(p_l[0], p_t[0], p_tl[0]);
880
512
    p[1] = clamp_add_subtract_half(p_l[1], p_t[1], p_tl[1]);
881
512
    p[2] = clamp_add_subtract_half(p_l[2], p_t[2], p_tl[2]);
882
512
    p[3] = clamp_add_subtract_half(p_l[3], p_t[3], p_tl[3]);
883
512
}
884
885
typedef void (*inv_predict_func)(uint8_t *p, const uint8_t *p_l,
886
                                 const uint8_t *p_tl, const uint8_t *p_t,
887
                                 const uint8_t *p_tr);
888
889
static const inv_predict_func inverse_predict[14] = {
890
    inv_predict_0,  inv_predict_1,  inv_predict_2,  inv_predict_3,
891
    inv_predict_4,  inv_predict_5,  inv_predict_6,  inv_predict_7,
892
    inv_predict_8,  inv_predict_9,  inv_predict_10, inv_predict_11,
893
    inv_predict_12, inv_predict_13,
894
};
895
896
65536
static void inverse_prediction(AVFrame *frame, enum PredictionMode m, int x, int y)
897
{
898
    uint8_t *dec, *p_l, *p_tl, *p_t, *p_tr;
899
    uint8_t p[4];
900
901
65536
    dec  = GET_PIXEL(frame, x,     y);
902
65536
    p_l  = GET_PIXEL(frame, x - 1, y);
903
65536
    p_tl = GET_PIXEL(frame, x - 1, y - 1);
904
65536
    p_t  = GET_PIXEL(frame, x,     y - 1);
905
65536
    if (x == frame->width - 1)
906
512
        p_tr = GET_PIXEL(frame, 0, y);
907
    else
908
65024
        p_tr = GET_PIXEL(frame, x + 1, y - 1);
909
910
65536
    inverse_predict[m](p, p_l, p_tl, p_t, p_tr);
911
912
65536
    dec[0] += p[0];
913
65536
    dec[1] += p[1];
914
65536
    dec[2] += p[2];
915
65536
    dec[3] += p[3];
916
65536
}
917
918
4
static int apply_predictor_transform(WebPContext *s)
919
{
920
4
    ImageContext *img  = &s->image[IMAGE_ROLE_ARGB];
921
4
    ImageContext *pimg = &s->image[IMAGE_ROLE_PREDICTOR];
922
    int x, y;
923
924
516
    for (y = 0; y < img->frame->height; y++) {
925
66048
        for (x = 0; x < img->frame->width; x++) {
926
65536
            int tx = x >> pimg->size_reduction;
927
65536
            int ty = y >> pimg->size_reduction;
928
65536
            enum PredictionMode m = GET_PIXEL_COMP(pimg->frame, tx, ty, 2);
929
930
65536
            if (x == 0) {
931
512
                if (y == 0)
932
4
                    m = PRED_MODE_BLACK;
933
                else
934
508
                    m = PRED_MODE_T;
935
65024
            } else if (y == 0)
936
508
                m = PRED_MODE_L;
937
938
65536
            if (m > 13) {
939
                av_log(s->avctx, AV_LOG_ERROR,
940
                       "invalid predictor mode: %d\n", m);
941
                return AVERROR_INVALIDDATA;
942
            }
943
65536
            inverse_prediction(img->frame, m, x, y);
944
        }
945
    }
946
4
    return 0;
947
}
948
949
196608
static av_always_inline uint8_t color_transform_delta(uint8_t color_pred,
950
                                                      uint8_t color)
951
{
952
196608
    return (int)ff_u8_to_s8(color_pred) * ff_u8_to_s8(color) >> 5;
953
}
954
955
4
static int apply_color_transform(WebPContext *s)
956
{
957
    ImageContext *img, *cimg;
958
    int x, y, cx, cy;
959
    uint8_t *p, *cp;
960
961
4
    img  = &s->image[IMAGE_ROLE_ARGB];
962
4
    cimg = &s->image[IMAGE_ROLE_COLOR_TRANSFORM];
963
964
516
    for (y = 0; y < img->frame->height; y++) {
965
66048
        for (x = 0; x < img->frame->width; x++) {
966
65536
            cx = x >> cimg->size_reduction;
967
65536
            cy = y >> cimg->size_reduction;
968
65536
            cp = GET_PIXEL(cimg->frame, cx, cy);
969
65536
            p  = GET_PIXEL(img->frame,   x,  y);
970
971
65536
            p[1] += color_transform_delta(cp[3], p[2]);
972
65536
            p[3] += color_transform_delta(cp[2], p[2]) +
973
65536
                    color_transform_delta(cp[1], p[1]);
974
        }
975
    }
976
4
    return 0;
977
}
978
979
4
static int apply_subtract_green_transform(WebPContext *s)
980
{
981
    int x, y;
982
4
    ImageContext *img = &s->image[IMAGE_ROLE_ARGB];
983
984
516
    for (y = 0; y < img->frame->height; y++) {
985
66048
        for (x = 0; x < img->frame->width; x++) {
986
65536
            uint8_t *p = GET_PIXEL(img->frame, x, y);
987
65536
            p[1] += p[2];
988
65536
            p[3] += p[2];
989
        }
990
    }
991
4
    return 0;
992
}
993
994
6
static int apply_color_indexing_transform(WebPContext *s)
995
{
996
    ImageContext *img;
997
    ImageContext *pal;
998
    int i, x, y;
999
    uint8_t *p;
1000
1001
6
    img = &s->image[IMAGE_ROLE_ARGB];
1002
6
    pal = &s->image[IMAGE_ROLE_COLOR_INDEXING];
1003
1004
6
    if (pal->size_reduction > 0) {
1005
        GetBitContext gb_g;
1006
        uint8_t *line;
1007
2
        int pixel_bits = 8 >> pal->size_reduction;
1008
1009
2
        line = av_malloc(img->frame->linesize[0] + AV_INPUT_BUFFER_PADDING_SIZE);
1010
2
        if (!line)
1011
            return AVERROR(ENOMEM);
1012
1013
18
        for (y = 0; y < img->frame->height; y++) {
1014
16
            p = GET_PIXEL(img->frame, 0, y);
1015
16
            memcpy(line, p, img->frame->linesize[0]);
1016
16
            init_get_bits(&gb_g, line, img->frame->linesize[0] * 8);
1017
16
            skip_bits(&gb_g, 16);
1018
16
            i = 0;
1019
208
            for (x = 0; x < img->frame->width; x++) {
1020
192
                p    = GET_PIXEL(img->frame, x, y);
1021
192
                p[2] = get_bits(&gb_g, pixel_bits);
1022
192
                i++;
1023
192
                if (i == 1 << pal->size_reduction) {
1024
48
                    skip_bits(&gb_g, 24);
1025
48
                    i = 0;
1026
                }
1027
            }
1028
        }
1029
2
        av_free(line);
1030
    }
1031
1032
    // switch to local palette if it's worth initializing it
1033
6
    if (img->frame->height * img->frame->width > 300) {
1034
        uint8_t palette[256 * 4];
1035
        const int size = pal->frame->width * 4;
1036
        av_assert0(size <= 1024U);
1037
        memcpy(palette, GET_PIXEL(pal->frame, 0, 0), size);   // copy palette
1038
        // set extra entries to transparent black
1039
        memset(palette + size, 0, 256 * 4 - size);
1040
        for (y = 0; y < img->frame->height; y++) {
1041
            for (x = 0; x < img->frame->width; x++) {
1042
                p = GET_PIXEL(img->frame, x, y);
1043
                i = p[2];
1044
                AV_COPY32(p, &palette[i * 4]);
1045
            }
1046
        }
1047
    } else {
1048
54
        for (y = 0; y < img->frame->height; y++) {
1049
624
            for (x = 0; x < img->frame->width; x++) {
1050
576
                p = GET_PIXEL(img->frame, x, y);
1051
576
                i = p[2];
1052
576
                if (i >= pal->frame->width) {
1053
                    AV_WB32(p, 0x00000000);
1054
                } else {
1055
576
                    const uint8_t *pi = GET_PIXEL(pal->frame, i, 0);
1056
576
                    AV_COPY32(p, pi);
1057
                }
1058
            }
1059
        }
1060
    }
1061
1062
6
    return 0;
1063
}
1064
1065
14
static void update_canvas_size(AVCodecContext *avctx, int w, int h)
1066
{
1067
14
    WebPContext *s = avctx->priv_data;
1068

14
    if (s->width && s->width != w) {
1069
        av_log(avctx, AV_LOG_WARNING, "Width mismatch. %d != %d\n",
1070
               s->width, w);
1071
    }
1072
14
    s->width = w;
1073

14
    if (s->height && s->height != h) {
1074
        av_log(avctx, AV_LOG_WARNING, "Height mismatch. %d != %d\n",
1075
               s->height, h);
1076
    }
1077
14
    s->height = h;
1078
14
}
1079
1080
10
static int vp8_lossless_decode_frame(AVCodecContext *avctx, AVFrame *p,
1081
                                     int *got_frame, uint8_t *data_start,
1082
                                     unsigned int data_size, int is_alpha_chunk)
1083
{
1084
10
    WebPContext *s = avctx->priv_data;
1085
    int w, h, ret, i, used;
1086
1087
10
    if (!is_alpha_chunk) {
1088
8
        s->lossless = 1;
1089
8
        avctx->pix_fmt = AV_PIX_FMT_ARGB;
1090
    }
1091
1092
10
    ret = init_get_bits8(&s->gb, data_start, data_size);
1093
10
    if (ret < 0)
1094
        return ret;
1095
1096
10
    if (!is_alpha_chunk) {
1097
8
        if (get_bits(&s->gb, 8) != 0x2F) {
1098
            av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless signature\n");
1099
            return AVERROR_INVALIDDATA;
1100
        }
1101
1102
8
        w = get_bits(&s->gb, 14) + 1;
1103
8
        h = get_bits(&s->gb, 14) + 1;
1104
1105
8
        update_canvas_size(avctx, w, h);
1106
1107
8
        ret = ff_set_dimensions(avctx, s->width, s->height);
1108
8
        if (ret < 0)
1109
            return ret;
1110
1111
8
        s->has_alpha = get_bits1(&s->gb);
1112
1113
8
        if (get_bits(&s->gb, 3) != 0x0) {
1114
            av_log(avctx, AV_LOG_ERROR, "Invalid WebP Lossless version\n");
1115
            return AVERROR_INVALIDDATA;
1116
        }
1117
    } else {
1118

2
        if (!s->width || !s->height)
1119
            return AVERROR_BUG;
1120
2
        w = s->width;
1121
2
        h = s->height;
1122
    }
1123
1124
    /* parse transformations */
1125
10
    s->nb_transforms = 0;
1126
10
    s->reduced_width = 0;
1127
10
    used = 0;
1128
28
    while (get_bits1(&s->gb)) {
1129
18
        enum TransformType transform = get_bits(&s->gb, 2);
1130
18
        if (used & (1 << transform)) {
1131
            av_log(avctx, AV_LOG_ERROR, "Transform %d used more than once\n",
1132
                   transform);
1133
            ret = AVERROR_INVALIDDATA;
1134
            goto free_and_return;
1135
        }
1136
18
        used |= (1 << transform);
1137
18
        s->transforms[s->nb_transforms++] = transform;
1138

18
        switch (transform) {
1139
4
        case PREDICTOR_TRANSFORM:
1140
4
            ret = parse_transform_predictor(s);
1141
4
            break;
1142
4
        case COLOR_TRANSFORM:
1143
4
            ret = parse_transform_color(s);
1144
4
            break;
1145
6
        case COLOR_INDEXING_TRANSFORM:
1146
6
            ret = parse_transform_color_indexing(s);
1147
6
            break;
1148
        }
1149
18
        if (ret < 0)
1150
            goto free_and_return;
1151
    }
1152
1153
    /* decode primary image */
1154
10
    s->image[IMAGE_ROLE_ARGB].frame = p;
1155
10
    if (is_alpha_chunk)
1156
2
        s->image[IMAGE_ROLE_ARGB].is_alpha_primary = 1;
1157
10
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_ARGB, w, h);
1158
10
    if (ret < 0)
1159
        goto free_and_return;
1160
1161
    /* apply transformations */
1162
28
    for (i = s->nb_transforms - 1; i >= 0; i--) {
1163

18
        switch (s->transforms[i]) {
1164
4
        case PREDICTOR_TRANSFORM:
1165
4
            ret = apply_predictor_transform(s);
1166
4
            break;
1167
4
        case COLOR_TRANSFORM:
1168
4
            ret = apply_color_transform(s);
1169
4
            break;
1170
4
        case SUBTRACT_GREEN:
1171
4
            ret = apply_subtract_green_transform(s);
1172
4
            break;
1173
6
        case COLOR_INDEXING_TRANSFORM:
1174
6
            ret = apply_color_indexing_transform(s);
1175
6
            break;
1176
        }
1177
18
        if (ret < 0)
1178
            goto free_and_return;
1179
    }
1180
1181
10
    *got_frame   = 1;
1182
10
    p->pict_type = AV_PICTURE_TYPE_I;
1183
10
    p->key_frame = 1;
1184
10
    ret          = data_size;
1185
1186
10
free_and_return:
1187
60
    for (i = 0; i < IMAGE_ROLE_NB; i++)
1188
50
        image_ctx_free(&s->image[i]);
1189
1190
10
    return ret;
1191
}
1192
1193
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
1194
{
1195
    int x, y, ls;
1196
    uint8_t *dec;
1197
1198
    ls = frame->linesize[3];
1199
1200
    /* filter first row using horizontal filter */
1201
    dec = frame->data[3] + 1;
1202
    for (x = 1; x < frame->width; x++, dec++)
1203
        *dec += *(dec - 1);
1204
1205
    /* filter first column using vertical filter */
1206
    dec = frame->data[3] + ls;
1207
    for (y = 1; y < frame->height; y++, dec += ls)
1208
        *dec += *(dec - ls);
1209
1210
    /* filter the rest using the specified filter */
1211
    switch (m) {
1212
    case ALPHA_FILTER_HORIZONTAL:
1213
        for (y = 1; y < frame->height; y++) {
1214
            dec = frame->data[3] + y * ls + 1;
1215
            for (x = 1; x < frame->width; x++, dec++)
1216
                *dec += *(dec - 1);
1217
        }
1218
        break;
1219
    case ALPHA_FILTER_VERTICAL:
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 - ls);
1224
        }
1225
        break;
1226
    case ALPHA_FILTER_GRADIENT:
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[0] += av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1231
        }
1232
        break;
1233
    }
1234
}
1235
1236
2
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p,
1237
                                  uint8_t *data_start,
1238
                                  unsigned int data_size)
1239
{
1240
2
    WebPContext *s = avctx->priv_data;
1241
    int x, y, ret;
1242
1243
2
    if (s->alpha_compression == ALPHA_COMPRESSION_NONE) {
1244
        GetByteContext gb;
1245
1246
        bytestream2_init(&gb, data_start, data_size);
1247
        for (y = 0; y < s->height; y++)
1248
            bytestream2_get_buffer(&gb, p->data[3] + p->linesize[3] * y,
1249
                                   s->width);
1250
2
    } else if (s->alpha_compression == ALPHA_COMPRESSION_VP8L) {
1251
        uint8_t *ap, *pp;
1252
2
        int alpha_got_frame = 0;
1253
1254
2
        s->alpha_frame = av_frame_alloc();
1255
2
        if (!s->alpha_frame)
1256
            return AVERROR(ENOMEM);
1257
1258
2
        ret = vp8_lossless_decode_frame(avctx, s->alpha_frame, &alpha_got_frame,
1259
                                        data_start, data_size, 1);
1260
2
        if (ret < 0) {
1261
            av_frame_free(&s->alpha_frame);
1262
            return ret;
1263
        }
1264
2
        if (!alpha_got_frame) {
1265
            av_frame_free(&s->alpha_frame);
1266
            return AVERROR_INVALIDDATA;
1267
        }
1268
1269
        /* copy green component of alpha image to alpha plane of primary image */
1270
18
        for (y = 0; y < s->height; y++) {
1271
16
            ap = GET_PIXEL(s->alpha_frame, 0, y) + 2;
1272
16
            pp = p->data[3] + p->linesize[3] * y;
1273
208
            for (x = 0; x < s->width; x++) {
1274
192
                *pp = *ap;
1275
192
                pp++;
1276
192
                ap += 4;
1277
            }
1278
        }
1279
2
        av_frame_free(&s->alpha_frame);
1280
    }
1281
1282
    /* apply alpha filtering */
1283
2
    if (s->alpha_filter)
1284
        alpha_inverse_prediction(p, s->alpha_filter);
1285
1286
2
    return 0;
1287
}
1288
1289
6
static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p,
1290
                                  int *got_frame, uint8_t *data_start,
1291
                                  unsigned int data_size)
1292
{
1293
6
    WebPContext *s = avctx->priv_data;
1294
    int ret;
1295
1296
6
    if (!s->initialized) {
1297
6
        ff_vp8_decode_init(avctx);
1298
6
        s->initialized = 1;
1299
6
        s->v.actually_webp = 1;
1300
    }
1301
6
    avctx->pix_fmt = s->has_alpha ? AV_PIX_FMT_YUVA420P : AV_PIX_FMT_YUV420P;
1302
6
    s->lossless = 0;
1303
1304
6
    if (data_size > INT_MAX) {
1305
        av_log(avctx, AV_LOG_ERROR, "unsupported chunk size\n");
1306
        return AVERROR_PATCHWELCOME;
1307
    }
1308
1309
6
    av_packet_unref(s->pkt);
1310
6
    s->pkt->data = data_start;
1311
6
    s->pkt->size = data_size;
1312
1313
6
    ret = ff_vp8_decode_frame(avctx, p, got_frame, s->pkt);
1314
6
    if (ret < 0)
1315
        return ret;
1316
1317
6
    if (!*got_frame)
1318
        return AVERROR_INVALIDDATA;
1319
1320
6
    update_canvas_size(avctx, avctx->width, avctx->height);
1321
1322
6
    if (s->has_alpha) {
1323
2
        ret = vp8_lossy_decode_alpha(avctx, p, s->alpha_data,
1324
2
                                     s->alpha_data_size);
1325
2
        if (ret < 0)
1326
            return ret;
1327
    }
1328
6
    return ret;
1329
}
1330
1331
14
static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1332
                             AVPacket *avpkt)
1333
{
1334
14
    AVFrame * const p = data;
1335
14
    WebPContext *s = avctx->priv_data;
1336
    GetByteContext gb;
1337
    int ret;
1338
    uint32_t chunk_type, chunk_size;
1339
14
    int vp8x_flags = 0;
1340
1341
14
    s->avctx     = avctx;
1342
14
    s->width     = 0;
1343
14
    s->height    = 0;
1344
14
    *got_frame   = 0;
1345
14
    s->has_alpha = 0;
1346
14
    s->has_exif  = 0;
1347
14
    s->has_iccp  = 0;
1348
14
    bytestream2_init(&gb, avpkt->data, avpkt->size);
1349
1350
14
    if (bytestream2_get_bytes_left(&gb) < 12)
1351
        return AVERROR_INVALIDDATA;
1352
1353
14
    if (bytestream2_get_le32(&gb) != MKTAG('R', 'I', 'F', 'F')) {
1354
        av_log(avctx, AV_LOG_ERROR, "missing RIFF tag\n");
1355
        return AVERROR_INVALIDDATA;
1356
    }
1357
1358
14
    chunk_size = bytestream2_get_le32(&gb);
1359
14
    if (bytestream2_get_bytes_left(&gb) < chunk_size)
1360
        return AVERROR_INVALIDDATA;
1361
1362
14
    if (bytestream2_get_le32(&gb) != MKTAG('W', 'E', 'B', 'P')) {
1363
        av_log(avctx, AV_LOG_ERROR, "missing WEBP tag\n");
1364
        return AVERROR_INVALIDDATA;
1365
    }
1366
1367
36
    while (bytestream2_get_bytes_left(&gb) > 8) {
1368
22
        char chunk_str[5] = { 0 };
1369
1370
22
        chunk_type = bytestream2_get_le32(&gb);
1371
22
        chunk_size = bytestream2_get_le32(&gb);
1372
22
        if (chunk_size == UINT32_MAX)
1373
            return AVERROR_INVALIDDATA;
1374
22
        chunk_size += chunk_size & 1;
1375
1376
22
        if (bytestream2_get_bytes_left(&gb) < chunk_size) {
1377
           /* we seem to be running out of data, but it could also be that the
1378
              bitstream has trailing junk leading to bogus chunk_size. */
1379
            break;
1380
        }
1381
1382


22
        switch (chunk_type) {
1383
6
        case MKTAG('V', 'P', '8', ' '):
1384
6
            if (!*got_frame) {
1385
6
                ret = vp8_lossy_decode_frame(avctx, p, got_frame,
1386
6
                                             avpkt->data + bytestream2_tell(&gb),
1387
                                             chunk_size);
1388
6
                if (ret < 0)
1389
                    return ret;
1390
            }
1391
6
            bytestream2_skip(&gb, chunk_size);
1392
6
            break;
1393
8
        case MKTAG('V', 'P', '8', 'L'):
1394
8
            if (!*got_frame) {
1395
8
                ret = vp8_lossless_decode_frame(avctx, p, got_frame,
1396
8
                                                avpkt->data + bytestream2_tell(&gb),
1397
                                                chunk_size, 0);
1398
8
                if (ret < 0)
1399
                    return ret;
1400
8
                avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
1401
            }
1402
8
            bytestream2_skip(&gb, chunk_size);
1403
8
            break;
1404
4
        case MKTAG('V', 'P', '8', 'X'):
1405

4
            if (s->width || s->height || *got_frame) {
1406
                av_log(avctx, AV_LOG_ERROR, "Canvas dimensions are already set\n");
1407
                return AVERROR_INVALIDDATA;
1408
            }
1409
4
            vp8x_flags = bytestream2_get_byte(&gb);
1410
4
            bytestream2_skip(&gb, 3);
1411
4
            s->width  = bytestream2_get_le24(&gb) + 1;
1412
4
            s->height = bytestream2_get_le24(&gb) + 1;
1413
4
            ret = av_image_check_size(s->width, s->height, 0, avctx);
1414
4
            if (ret < 0)
1415
                return ret;
1416
4
            break;
1417
2
        case MKTAG('A', 'L', 'P', 'H'): {
1418
            int alpha_header, filter_m, compression;
1419
1420
2
            if (!(vp8x_flags & VP8X_FLAG_ALPHA)) {
1421
                av_log(avctx, AV_LOG_WARNING,
1422
                       "ALPHA chunk present, but alpha bit not set in the "
1423
                       "VP8X header\n");
1424
            }
1425
2
            if (chunk_size == 0) {
1426
                av_log(avctx, AV_LOG_ERROR, "invalid ALPHA chunk size\n");
1427
                return AVERROR_INVALIDDATA;
1428
            }
1429
2
            alpha_header       = bytestream2_get_byte(&gb);
1430
2
            s->alpha_data      = avpkt->data + bytestream2_tell(&gb);
1431
2
            s->alpha_data_size = chunk_size - 1;
1432
2
            bytestream2_skip(&gb, s->alpha_data_size);
1433
1434
2
            filter_m    = (alpha_header >> 2) & 0x03;
1435
2
            compression =  alpha_header       & 0x03;
1436
1437
2
            if (compression > ALPHA_COMPRESSION_VP8L) {
1438
                av_log(avctx, AV_LOG_VERBOSE,
1439
                       "skipping unsupported ALPHA chunk\n");
1440
            } else {
1441
2
                s->has_alpha         = 1;
1442
2
                s->alpha_compression = compression;
1443
2
                s->alpha_filter      = filter_m;
1444
            }
1445
1446
2
            break;
1447
        }
1448
2
        case MKTAG('E', 'X', 'I', 'F'): {
1449
2
            int le, ifd_offset, exif_offset = bytestream2_tell(&gb);
1450
2
            AVDictionary *exif_metadata = NULL;
1451
            GetByteContext exif_gb;
1452
1453
2
            if (s->has_exif) {
1454
                av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra EXIF chunk\n");
1455
                goto exif_end;
1456
            }
1457
2
            if (!(vp8x_flags & VP8X_FLAG_EXIF_METADATA))
1458
                av_log(avctx, AV_LOG_WARNING,
1459
                       "EXIF chunk present, but Exif bit not set in the "
1460
                       "VP8X header\n");
1461
1462
2
            s->has_exif = 1;
1463
2
            bytestream2_init(&exif_gb, avpkt->data + exif_offset,
1464
2
                             avpkt->size - exif_offset);
1465
2
            if (ff_tdecode_header(&exif_gb, &le, &ifd_offset) < 0) {
1466
                av_log(avctx, AV_LOG_ERROR, "invalid TIFF header "
1467
                       "in Exif data\n");
1468
                goto exif_end;
1469
            }
1470
1471
2
            bytestream2_seek(&exif_gb, ifd_offset, SEEK_SET);
1472
2
            if (ff_exif_decode_ifd(avctx, &exif_gb, le, 0, &exif_metadata) < 0) {
1473
                av_log(avctx, AV_LOG_ERROR, "error decoding Exif data\n");
1474
                goto exif_end;
1475
            }
1476
1477
2
            av_dict_copy(&((AVFrame *) data)->metadata, exif_metadata, 0);
1478
1479
2
exif_end:
1480
2
            av_dict_free(&exif_metadata);
1481
2
            bytestream2_skip(&gb, chunk_size);
1482
2
            break;
1483
        }
1484
        case MKTAG('I', 'C', 'C', 'P'): {
1485
            AVFrameSideData *sd;
1486
1487
            if (s->has_iccp) {
1488
                av_log(avctx, AV_LOG_VERBOSE, "Ignoring extra ICCP chunk\n");
1489
                bytestream2_skip(&gb, chunk_size);
1490
                break;
1491
            }
1492
            if (!(vp8x_flags & VP8X_FLAG_ICC))
1493
                av_log(avctx, AV_LOG_WARNING,
1494
                       "ICCP chunk present, but ICC Profile bit not set in the "
1495
                       "VP8X header\n");
1496
1497
            s->has_iccp = 1;
1498
            sd = av_frame_new_side_data(p, AV_FRAME_DATA_ICC_PROFILE, chunk_size);
1499
            if (!sd)
1500
                return AVERROR(ENOMEM);
1501
1502
            bytestream2_get_buffer(&gb, sd->data, chunk_size);
1503
            break;
1504
        }
1505
        case MKTAG('A', 'N', 'I', 'M'):
1506
        case MKTAG('A', 'N', 'M', 'F'):
1507
        case MKTAG('X', 'M', 'P', ' '):
1508
            AV_WL32(chunk_str, chunk_type);
1509
            av_log(avctx, AV_LOG_WARNING, "skipping unsupported chunk: %s\n",
1510
                   chunk_str);
1511
            bytestream2_skip(&gb, chunk_size);
1512
            break;
1513
        default:
1514
            AV_WL32(chunk_str, chunk_type);
1515
            av_log(avctx, AV_LOG_VERBOSE, "skipping unknown chunk: %s\n",
1516
                   chunk_str);
1517
            bytestream2_skip(&gb, chunk_size);
1518
            break;
1519
        }
1520
    }
1521
1522
14
    if (!*got_frame) {
1523
        av_log(avctx, AV_LOG_ERROR, "image data not found\n");
1524
        return AVERROR_INVALIDDATA;
1525
    }
1526
1527
14
    return avpkt->size;
1528
}
1529
1530
14
static av_cold int webp_decode_init(AVCodecContext *avctx)
1531
{
1532
14
    WebPContext *s = avctx->priv_data;
1533
1534
14
    s->pkt = av_packet_alloc();
1535
14
    if (!s->pkt)
1536
        return AVERROR(ENOMEM);
1537
1538
14
    return 0;
1539
}
1540
1541
14
static av_cold int webp_decode_close(AVCodecContext *avctx)
1542
{
1543
14
    WebPContext *s = avctx->priv_data;
1544
1545
14
    av_packet_free(&s->pkt);
1546
1547
14
    if (s->initialized)
1548
6
        return ff_vp8_decode_free(avctx);
1549
1550
8
    return 0;
1551
}
1552
1553
AVCodec ff_webp_decoder = {
1554
    .name           = "webp",
1555
    .long_name      = NULL_IF_CONFIG_SMALL("WebP image"),
1556
    .type           = AVMEDIA_TYPE_VIDEO,
1557
    .id             = AV_CODEC_ID_WEBP,
1558
    .priv_data_size = sizeof(WebPContext),
1559
    .init           = webp_decode_init,
1560
    .decode         = webp_decode_frame,
1561
    .close          = webp_decode_close,
1562
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1563
};