GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/webp.c Lines: 605 792 76.4 %
Date: 2021-01-22 05:18:52 Branches: 258 391 66.0 %

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
    AVCodecContext *avctx;              /* parent AVCodecContext */
193
    int initialized;                    /* set once the VP8 context is initialized */
194
    int has_alpha;                      /* has a separate alpha chunk */
195
    enum AlphaCompression alpha_compression; /* compression type for alpha chunk */
196
    enum AlphaFilter alpha_filter;      /* filtering method for alpha chunk */
197
    uint8_t *alpha_data;                /* alpha chunk data */
198
    int alpha_data_size;                /* alpha chunk data size */
199
    int has_exif;                       /* set after an EXIF chunk has been processed */
200
    int has_iccp;                       /* set after an ICCP chunk has been processed */
201
    int width;                          /* image width */
202
    int height;                         /* image height */
203
    int lossless;                       /* indicates lossless or lossy */
204
205
    int nb_transforms;                  /* number of transforms */
206
    enum TransformType transforms[4];   /* transformations used in the image, in order */
207
    int reduced_width;                  /* reduced width for index image, if applicable */
208
    int nb_huffman_groups;              /* number of huffman groups in the primary image */
209
    ImageContext image[IMAGE_ROLE_NB];  /* image context for each role */
210
} WebPContext;
211
212
#define GET_PIXEL(frame, x, y) \
213
    ((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x))
214
215
#define GET_PIXEL_COMP(frame, x, y, c) \
216
    (*((frame)->data[0] + (y) * frame->linesize[0] + 4 * (x) + c))
217
218
50
static void image_ctx_free(ImageContext *img)
219
{
220
    int i, j;
221
222
50
    av_free(img->color_cache);
223

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

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

1264
            switch (code_len) {
377
868
            case 16:
378
                /* Code 16 repeats the previous non-zero value [3..6] times,
379
                 * i.e., 3 + ReadBits(2) times. If code 16 is used before a
380
                 * non-zero value has been emitted, a value of 8 is repeated. */
381
868
                repeat = 3 + get_bits(&s->gb, 2);
382
868
                length = prev_code_len;
383
868
                break;
384
140
            case 17:
385
                /* Code 17 emits a streak of zeros [3..10], i.e.,
386
                 * 3 + ReadBits(3) times. */
387
140
                repeat = 3 + get_bits(&s->gb, 3);
388
140
                break;
389
256
            case 18:
390
                /* Code 18 emits a streak of zeros of length [11..138], i.e.,
391
                 * 11 + ReadBits(7) times. */
392
256
                repeat = 11 + get_bits(&s->gb, 7);
393
256
                break;
394
            }
395
1264
            if (symbol + repeat > alphabet_size) {
396
                av_log(s->avctx, AV_LOG_ERROR,
397
                       "invalid symbol %d + repeat %d > alphabet size %d\n",
398
                       symbol, repeat, alphabet_size);
399
                ret = AVERROR_INVALIDDATA;
400
                goto finish;
401
            }
402
19354
            while (repeat-- > 0)
403
18090
                code_lengths[symbol++] = length;
404
        }
405
    }
406
407
78
    ret = huff_reader_build_canonical(hc, code_lengths, alphabet_size);
408
409
78
finish:
410
78
    ff_free_vlc(&code_len_hc.vlc);
411
78
    av_free(code_lengths);
412
78
    return ret;
413
}
414
415
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
416
                                      int w, int h);
417
418
#define PARSE_BLOCK_SIZE(w, h) do {                                         \
419
    block_bits = get_bits(&s->gb, 3) + 2;                                   \
420
    blocks_w   = FFALIGN((w), 1 << block_bits) >> block_bits;               \
421
    blocks_h   = FFALIGN((h), 1 << block_bits) >> block_bits;               \
422
} while (0)
423
424
4
static int decode_entropy_image(WebPContext *s)
425
{
426
    ImageContext *img;
427
    int ret, block_bits, width, blocks_w, blocks_h, x, y, max;
428
429
4
    width = s->width;
430
4
    if (s->reduced_width > 0)
431
        width = s->reduced_width;
432
433
4
    PARSE_BLOCK_SIZE(width, s->height);
434
435
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_ENTROPY, blocks_w, blocks_h);
436
4
    if (ret < 0)
437
        return ret;
438
439
4
    img = &s->image[IMAGE_ROLE_ENTROPY];
440
4
    img->size_reduction = block_bits;
441
442
    /* the number of huffman groups is determined by the maximum group number
443
     * coded in the entropy image */
444
4
    max = 0;
445
68
    for (y = 0; y < img->frame->height; y++) {
446
1088
        for (x = 0; x < img->frame->width; x++) {
447
1024
            int p0 = GET_PIXEL_COMP(img->frame, x, y, 1);
448
1024
            int p1 = GET_PIXEL_COMP(img->frame, x, y, 2);
449
1024
            int p  = p0 << 8 | p1;
450
1024
            max = FFMAX(max, p);
451
        }
452
    }
453
4
    s->nb_huffman_groups = max + 1;
454
455
4
    return 0;
456
}
457
458
4
static int parse_transform_predictor(WebPContext *s)
459
{
460
    int block_bits, blocks_w, blocks_h, ret;
461
462
4
    PARSE_BLOCK_SIZE(s->width, s->height);
463
464
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_PREDICTOR, blocks_w,
465
                                     blocks_h);
466
4
    if (ret < 0)
467
        return ret;
468
469
4
    s->image[IMAGE_ROLE_PREDICTOR].size_reduction = block_bits;
470
471
4
    return 0;
472
}
473
474
4
static int parse_transform_color(WebPContext *s)
475
{
476
    int block_bits, blocks_w, blocks_h, ret;
477
478
4
    PARSE_BLOCK_SIZE(s->width, s->height);
479
480
4
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_TRANSFORM, blocks_w,
481
                                     blocks_h);
482
4
    if (ret < 0)
483
        return ret;
484
485
4
    s->image[IMAGE_ROLE_COLOR_TRANSFORM].size_reduction = block_bits;
486
487
4
    return 0;
488
}
489
490
6
static int parse_transform_color_indexing(WebPContext *s)
491
{
492
    ImageContext *img;
493
    int width_bits, index_size, ret, x;
494
    uint8_t *ct;
495
496
6
    index_size = get_bits(&s->gb, 8) + 1;
497
498
6
    if (index_size <= 2)
499
        width_bits = 3;
500
6
    else if (index_size <= 4)
501
2
        width_bits = 2;
502
4
    else if (index_size <= 16)
503
        width_bits = 1;
504
    else
505
4
        width_bits = 0;
506
507
6
    ret = decode_entropy_coded_image(s, IMAGE_ROLE_COLOR_INDEXING,
508
                                     index_size, 1);
509
6
    if (ret < 0)
510
        return ret;
511
512
6
    img = &s->image[IMAGE_ROLE_COLOR_INDEXING];
513
6
    img->size_reduction = width_bits;
514
6
    if (width_bits > 0)
515
2
        s->reduced_width = (s->width + ((1 << width_bits) - 1)) >> width_bits;
516
517
    /* color index values are delta-coded */
518
6
    ct  = img->frame->data[0] + 4;
519
1422
    for (x = 4; x < img->frame->width * 4; x++, ct++)
520
1416
        ct[0] += ct[-4];
521
522
6
    return 0;
523
}
524
525
68752
static HuffReader *get_huffman_group(WebPContext *s, ImageContext *img,
526
                                     int x, int y)
527
{
528
68752
    ImageContext *gimg = &s->image[IMAGE_ROLE_ENTROPY];
529
68752
    int group = 0;
530
531
68752
    if (gimg->size_reduction > 0) {
532
65536
        int group_x = x >> gimg->size_reduction;
533
65536
        int group_y = y >> gimg->size_reduction;
534
65536
        int g0      = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 1);
535
65536
        int g1      = GET_PIXEL_COMP(gimg->frame, group_x, group_y, 2);
536
65536
        group       = g0 << 8 | g1;
537
    }
538
539
68752
    return &img->huffman_groups[group * HUFFMAN_CODES_PER_META_CODE];
540
}
541
542
static av_always_inline void color_cache_put(ImageContext *img, uint32_t c)
543
{
544
    uint32_t cache_idx = (0x1E35A7BD * c) >> (32 - img->color_cache_bits);
545
    img->color_cache[cache_idx] = c;
546
}
547
548
28
static int decode_entropy_coded_image(WebPContext *s, enum ImageRole role,
549
                                      int w, int h)
550
{
551
    ImageContext *img;
552
    HuffReader *hg;
553
    int i, j, ret, x, y, width;
554
555
28
    img       = &s->image[role];
556
28
    img->role = role;
557
558
28
    if (!img->frame) {
559
18
        img->frame = av_frame_alloc();
560
18
        if (!img->frame)
561
            return AVERROR(ENOMEM);
562
    }
563
564
28
    img->frame->format = AV_PIX_FMT_ARGB;
565
28
    img->frame->width  = w;
566
28
    img->frame->height = h;
567
568

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

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

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

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

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

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

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

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

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

18
        switch (s->transforms[i]) {
1163
4
        case PREDICTOR_TRANSFORM:
1164
4
            ret = apply_predictor_transform(s);
1165
4
            break;
1166
4
        case COLOR_TRANSFORM:
1167
4
            ret = apply_color_transform(s);
1168
4
            break;
1169
4
        case SUBTRACT_GREEN:
1170
4
            ret = apply_subtract_green_transform(s);
1171
4
            break;
1172
6
        case COLOR_INDEXING_TRANSFORM:
1173
6
            ret = apply_color_indexing_transform(s);
1174
6
            break;
1175
        }
1176
18
        if (ret < 0)
1177
            goto free_and_return;
1178
    }
1179
1180
10
    *got_frame   = 1;
1181
10
    p->pict_type = AV_PICTURE_TYPE_I;
1182
10
    p->key_frame = 1;
1183
10
    ret          = data_size;
1184
1185
10
free_and_return:
1186
60
    for (i = 0; i < IMAGE_ROLE_NB; i++)
1187
50
        image_ctx_free(&s->image[i]);
1188
1189
10
    return ret;
1190
}
1191
1192
static void alpha_inverse_prediction(AVFrame *frame, enum AlphaFilter m)
1193
{
1194
    int x, y, ls;
1195
    uint8_t *dec;
1196
1197
    ls = frame->linesize[3];
1198
1199
    /* filter first row using horizontal filter */
1200
    dec = frame->data[3] + 1;
1201
    for (x = 1; x < frame->width; x++, dec++)
1202
        *dec += *(dec - 1);
1203
1204
    /* filter first column using vertical filter */
1205
    dec = frame->data[3] + ls;
1206
    for (y = 1; y < frame->height; y++, dec += ls)
1207
        *dec += *(dec - ls);
1208
1209
    /* filter the rest using the specified filter */
1210
    switch (m) {
1211
    case ALPHA_FILTER_HORIZONTAL:
1212
        for (y = 1; y < frame->height; y++) {
1213
            dec = frame->data[3] + y * ls + 1;
1214
            for (x = 1; x < frame->width; x++, dec++)
1215
                *dec += *(dec - 1);
1216
        }
1217
        break;
1218
    case ALPHA_FILTER_VERTICAL:
1219
        for (y = 1; y < frame->height; y++) {
1220
            dec = frame->data[3] + y * ls + 1;
1221
            for (x = 1; x < frame->width; x++, dec++)
1222
                *dec += *(dec - ls);
1223
        }
1224
        break;
1225
    case ALPHA_FILTER_GRADIENT:
1226
        for (y = 1; y < frame->height; y++) {
1227
            dec = frame->data[3] + y * ls + 1;
1228
            for (x = 1; x < frame->width; x++, dec++)
1229
                dec[0] += av_clip_uint8(*(dec - 1) + *(dec - ls) - *(dec - ls - 1));
1230
        }
1231
        break;
1232
    }
1233
}
1234
1235
2
static int vp8_lossy_decode_alpha(AVCodecContext *avctx, AVFrame *p,
1236
                                  uint8_t *data_start,
1237
                                  unsigned int data_size)
1238
{
1239
2
    WebPContext *s = avctx->priv_data;
1240
    int x, y, ret;
1241
1242
2
    if (s->alpha_compression == ALPHA_COMPRESSION_NONE) {
1243
        GetByteContext gb;
1244
1245
        bytestream2_init(&gb, data_start, data_size);
1246
        for (y = 0; y < s->height; y++)
1247
            bytestream2_get_buffer(&gb, p->data[3] + p->linesize[3] * y,
1248
                                   s->width);
1249
2
    } else if (s->alpha_compression == ALPHA_COMPRESSION_VP8L) {
1250
        uint8_t *ap, *pp;
1251
2
        int alpha_got_frame = 0;
1252
1253
2
        s->alpha_frame = av_frame_alloc();
1254
2
        if (!s->alpha_frame)
1255
            return AVERROR(ENOMEM);
1256
1257
2
        ret = vp8_lossless_decode_frame(avctx, s->alpha_frame, &alpha_got_frame,
1258
                                        data_start, data_size, 1);
1259
2
        if (ret < 0) {
1260
            av_frame_free(&s->alpha_frame);
1261
            return ret;
1262
        }
1263
2
        if (!alpha_got_frame) {
1264
            av_frame_free(&s->alpha_frame);
1265
            return AVERROR_INVALIDDATA;
1266
        }
1267
1268
        /* copy green component of alpha image to alpha plane of primary image */
1269
18
        for (y = 0; y < s->height; y++) {
1270
16
            ap = GET_PIXEL(s->alpha_frame, 0, y) + 2;
1271
16
            pp = p->data[3] + p->linesize[3] * y;
1272
208
            for (x = 0; x < s->width; x++) {
1273
192
                *pp = *ap;
1274
192
                pp++;
1275
192
                ap += 4;
1276
            }
1277
        }
1278
2
        av_frame_free(&s->alpha_frame);
1279
    }
1280
1281
    /* apply alpha filtering */
1282
2
    if (s->alpha_filter)
1283
        alpha_inverse_prediction(p, s->alpha_filter);
1284
1285
2
    return 0;
1286
}
1287
1288
6
static int vp8_lossy_decode_frame(AVCodecContext *avctx, AVFrame *p,
1289
                                  int *got_frame, uint8_t *data_start,
1290
                                  unsigned int data_size)
1291
{
1292
6
    WebPContext *s = avctx->priv_data;
1293
    AVPacket pkt;
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_init_packet(&pkt);
1310
6
    pkt.data = data_start;
1311
6
    pkt.size = data_size;
1312
1313
6
    ret = ff_vp8_decode_frame(avctx, p, got_frame, &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_close(AVCodecContext *avctx)
1531
{
1532
14
    WebPContext *s = avctx->priv_data;
1533
1534
14
    if (s->initialized)
1535
6
        return ff_vp8_decode_free(avctx);
1536
1537
8
    return 0;
1538
}
1539
1540
AVCodec ff_webp_decoder = {
1541
    .name           = "webp",
1542
    .long_name      = NULL_IF_CONFIG_SMALL("WebP image"),
1543
    .type           = AVMEDIA_TYPE_VIDEO,
1544
    .id             = AV_CODEC_ID_WEBP,
1545
    .priv_data_size = sizeof(WebPContext),
1546
    .decode         = webp_decode_frame,
1547
    .close          = webp_decode_close,
1548
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1549
};