GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/agm.c Lines: 0 774 0.0 %
Date: 2020-11-28 20:53:16 Branches: 0 481 0.0 %

Line Branch Exec Source
1
/*
2
 * Amuse Graphics Movie decoder
3
 *
4
 * Copyright (c) 2018 Paul B Mahol
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
#include <stdio.h>
24
#include <stdlib.h>
25
#include <string.h>
26
27
#define BITSTREAM_READER_LE
28
29
#include "avcodec.h"
30
#include "bytestream.h"
31
#include "copy_block.h"
32
#include "get_bits.h"
33
#include "idctdsp.h"
34
#include "internal.h"
35
36
static const uint8_t unscaled_luma[64] = {
37
    16, 11, 10, 16, 24, 40, 51, 61, 12, 12, 14, 19,
38
    26, 58, 60, 55, 14, 13, 16, 24, 40, 57, 69, 56,
39
    14, 17, 22, 29, 51, 87, 80, 62, 18, 22, 37, 56,
40
    68,109,103, 77, 24, 35, 55, 64, 81,104,113, 92,
41
    49, 64, 78, 87,103,121,120,101, 72, 92, 95, 98,
42
    112,100,103,99
43
};
44
45
static const uint8_t unscaled_chroma[64] = {
46
    17, 18, 24, 47, 99, 99, 99, 99, 18, 21, 26, 66,
47
    99, 99, 99, 99, 24, 26, 56, 99, 99, 99, 99, 99,
48
    47, 66, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
49
    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
50
    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
51
    99, 99, 99, 99
52
};
53
54
typedef struct MotionVector {
55
    int16_t x, y;
56
} MotionVector;
57
58
typedef struct AGMContext {
59
    const AVClass  *class;
60
    AVCodecContext *avctx;
61
    GetBitContext   gb;
62
    GetByteContext  gbyte;
63
64
    int key_frame;
65
    int bitstream_size;
66
    int compression;
67
    int blocks_w;
68
    int blocks_h;
69
    int size[3];
70
    int plus;
71
    int dct;
72
    int rgb;
73
    unsigned flags;
74
    unsigned fflags;
75
76
    uint8_t *output;
77
    unsigned padded_output_size;
78
    unsigned output_size;
79
80
    MotionVector *mvectors;
81
    unsigned      mvectors_size;
82
83
    VLC vlc;
84
85
    AVFrame *prev_frame;
86
87
    int luma_quant_matrix[64];
88
    int chroma_quant_matrix[64];
89
90
    ScanTable scantable;
91
    DECLARE_ALIGNED(32, int16_t, block)[64];
92
93
    int16_t *wblocks;
94
    unsigned wblocks_size;
95
96
    int      *map;
97
    unsigned  map_size;
98
99
    IDCTDSPContext idsp;
100
} AGMContext;
101
102
static int read_code(GetBitContext *gb, int *oskip, int *level, int *map, int mode)
103
{
104
    int len = 0, skip = 0, max;
105
106
    if (get_bits_left(gb) < 2)
107
        return AVERROR_INVALIDDATA;
108
109
    if (show_bits(gb, 2)) {
110
        switch (show_bits(gb, 4)) {
111
        case 1:
112
        case 9:
113
            len = 1;
114
            skip = 3;
115
            break;
116
        case 2:
117
            len = 3;
118
            skip = 4;
119
            break;
120
        case 3:
121
            len = 7;
122
            skip = 4;
123
            break;
124
        case 5:
125
        case 13:
126
            len = 2;
127
            skip = 3;
128
            break;
129
        case 6:
130
            len = 4;
131
            skip = 4;
132
            break;
133
        case 7:
134
            len = 8;
135
            skip = 4;
136
            break;
137
        case 10:
138
            len = 5;
139
            skip = 4;
140
            break;
141
        case 11:
142
            len = 9;
143
            skip = 4;
144
            break;
145
        case 14:
146
            len = 6;
147
            skip = 4;
148
            break;
149
        case 15:
150
            len = ((show_bits(gb, 5) & 0x10) | 0xA0) >> 4;
151
            skip = 5;
152
            break;
153
        default:
154
            return AVERROR_INVALIDDATA;
155
        }
156
157
        skip_bits(gb, skip);
158
        *level = get_bits(gb, len);
159
        *map = 1;
160
        *oskip = 0;
161
        max = 1 << (len - 1);
162
        if (*level < max)
163
            *level = -(max + *level);
164
    } else if (show_bits(gb, 3) & 4) {
165
        skip_bits(gb, 3);
166
        if (mode == 1) {
167
            if (show_bits(gb, 4)) {
168
                if (show_bits(gb, 4) == 1) {
169
                    skip_bits(gb, 4);
170
                    *oskip = get_bits(gb, 16);
171
                } else {
172
                    *oskip = get_bits(gb, 4);
173
                }
174
            } else {
175
                skip_bits(gb, 4);
176
                *oskip = get_bits(gb, 10);
177
            }
178
        } else if (mode == 0) {
179
            *oskip = get_bits(gb, 10);
180
        }
181
        *level = 0;
182
    } else {
183
        skip_bits(gb, 3);
184
        if (mode == 0)
185
            *oskip = get_bits(gb, 4);
186
        else if (mode == 1)
187
            *oskip = 0;
188
        *level = 0;
189
    }
190
191
    return 0;
192
}
193
194
static int decode_intra_blocks(AGMContext *s, GetBitContext *gb,
195
                               const int *quant_matrix, int *skip, int *dc_level)
196
{
197
    const uint8_t *scantable = s->scantable.permutated;
198
    int level, ret, map = 0;
199
200
    memset(s->wblocks, 0, s->wblocks_size);
201
202
    for (int i = 0; i < 64; i++) {
203
        int16_t *block = s->wblocks + scantable[i];
204
205
        for (int j = 0; j < s->blocks_w;) {
206
            if (*skip > 0) {
207
                int rskip;
208
209
                rskip = FFMIN(*skip, s->blocks_w - j);
210
                j += rskip;
211
                if (i == 0) {
212
                    for (int k = 0; k < rskip; k++)
213
                        block[64 * k] = *dc_level * quant_matrix[0];
214
                }
215
                block += rskip * 64;
216
                *skip -= rskip;
217
            } else {
218
                ret = read_code(gb, skip, &level, &map, s->flags & 1);
219
                if (ret < 0)
220
                    return ret;
221
222
                if (i == 0)
223
                    *dc_level += level;
224
225
                block[0] = (i == 0 ? *dc_level : level) * quant_matrix[i];
226
                block += 64;
227
                j++;
228
            }
229
        }
230
    }
231
232
    return 0;
233
}
234
235
static int decode_inter_blocks(AGMContext *s, GetBitContext *gb,
236
                               const int *quant_matrix, int *skip,
237
                               int *map)
238
{
239
    const uint8_t *scantable = s->scantable.permutated;
240
    int level, ret;
241
242
    memset(s->wblocks, 0, s->wblocks_size);
243
    memset(s->map, 0, s->map_size);
244
245
    for (int i = 0; i < 64; i++) {
246
        int16_t *block = s->wblocks + scantable[i];
247
248
        for (int j = 0; j < s->blocks_w;) {
249
            if (*skip > 0) {
250
                int rskip;
251
252
                rskip = FFMIN(*skip, s->blocks_w - j);
253
                j += rskip;
254
                block += rskip * 64;
255
                *skip -= rskip;
256
            } else {
257
                ret = read_code(gb, skip, &level, &map[j], s->flags & 1);
258
                if (ret < 0)
259
                    return ret;
260
261
                block[0] = level * quant_matrix[i];
262
                block += 64;
263
                j++;
264
            }
265
        }
266
    }
267
268
    return 0;
269
}
270
271
static int decode_intra_block(AGMContext *s, GetBitContext *gb,
272
                              const int *quant_matrix, int *skip, int *dc_level)
273
{
274
    const uint8_t *scantable = s->scantable.permutated;
275
    const int offset = s->plus ? 0 : 1024;
276
    int16_t *block = s->block;
277
    int level, ret, map = 0;
278
279
    memset(block, 0, sizeof(s->block));
280
281
    if (*skip > 0) {
282
        (*skip)--;
283
    } else {
284
        ret = read_code(gb, skip, &level, &map, s->flags & 1);
285
        if (ret < 0)
286
            return ret;
287
        *dc_level += level;
288
    }
289
    block[scantable[0]] = offset + *dc_level * quant_matrix[0];
290
291
    for (int i = 1; i < 64;) {
292
        if (*skip > 0) {
293
            int rskip;
294
295
            rskip = FFMIN(*skip, 64 - i);
296
            i += rskip;
297
            *skip -= rskip;
298
        } else {
299
            ret = read_code(gb, skip, &level, &map, s->flags & 1);
300
            if (ret < 0)
301
                return ret;
302
303
            block[scantable[i]] = level * quant_matrix[i];
304
            i++;
305
        }
306
    }
307
308
    return 0;
309
}
310
311
static int decode_intra_plane(AGMContext *s, GetBitContext *gb, int size,
312
                              const int *quant_matrix, AVFrame *frame,
313
                              int plane)
314
{
315
    int ret, skip = 0, dc_level = 0;
316
    const int offset = s->plus ? 0 : 1024;
317
318
    if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
319
        return ret;
320
321
    if (s->flags & 1) {
322
        av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
323
                              64 * s->blocks_w * sizeof(*s->wblocks));
324
        if (!s->wblocks)
325
            return AVERROR(ENOMEM);
326
327
        for (int y = 0; y < s->blocks_h; y++) {
328
            ret = decode_intra_blocks(s, gb, quant_matrix, &skip, &dc_level);
329
            if (ret < 0)
330
                return ret;
331
332
            for (int x = 0; x < s->blocks_w; x++) {
333
                s->wblocks[64 * x] += offset;
334
                s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
335
                                 frame->linesize[plane], s->wblocks + 64 * x);
336
            }
337
        }
338
    } else {
339
        for (int y = 0; y < s->blocks_h; y++) {
340
            for (int x = 0; x < s->blocks_w; x++) {
341
                ret = decode_intra_block(s, gb, quant_matrix, &skip, &dc_level);
342
                if (ret < 0)
343
                    return ret;
344
345
                s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
346
                                 frame->linesize[plane], s->block);
347
            }
348
        }
349
    }
350
351
    align_get_bits(gb);
352
    if (get_bits_left(gb) < 0)
353
        av_log(s->avctx, AV_LOG_WARNING, "overread\n");
354
    if (get_bits_left(gb) > 0)
355
        av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
356
357
    return 0;
358
}
359
360
static int decode_inter_block(AGMContext *s, GetBitContext *gb,
361
                              const int *quant_matrix, int *skip,
362
                              int *map)
363
{
364
    const uint8_t *scantable = s->scantable.permutated;
365
    int16_t *block = s->block;
366
    int level, ret;
367
368
    memset(block, 0, sizeof(s->block));
369
370
    for (int i = 0; i < 64;) {
371
        if (*skip > 0) {
372
            int rskip;
373
374
            rskip = FFMIN(*skip, 64 - i);
375
            i += rskip;
376
            *skip -= rskip;
377
        } else {
378
            ret = read_code(gb, skip, &level, map, s->flags & 1);
379
            if (ret < 0)
380
                return ret;
381
382
            block[scantable[i]] = level * quant_matrix[i];
383
            i++;
384
        }
385
    }
386
387
    return 0;
388
}
389
390
static int decode_inter_plane(AGMContext *s, GetBitContext *gb, int size,
391
                              const int *quant_matrix, AVFrame *frame,
392
                              AVFrame *prev, int plane)
393
{
394
    int ret, skip = 0;
395
396
    if ((ret = init_get_bits8(gb, s->gbyte.buffer, size)) < 0)
397
        return ret;
398
399
    if (s->flags == 3) {
400
        av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
401
                              64 * s->blocks_w * sizeof(*s->wblocks));
402
        if (!s->wblocks)
403
            return AVERROR(ENOMEM);
404
405
        av_fast_padded_malloc(&s->map, &s->map_size,
406
                              s->blocks_w * sizeof(*s->map));
407
        if (!s->map)
408
            return AVERROR(ENOMEM);
409
410
        for (int y = 0; y < s->blocks_h; y++) {
411
            ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
412
            if (ret < 0)
413
                return ret;
414
415
            for (int x = 0; x < s->blocks_w; x++) {
416
                int shift = plane == 0;
417
                int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
418
                int orig_mv_x = s->mvectors[mvpos].x;
419
                int mv_x = s->mvectors[mvpos].x / (1 + !shift);
420
                int mv_y = s->mvectors[mvpos].y / (1 + !shift);
421
                int h = s->avctx->coded_height >> !shift;
422
                int w = s->avctx->coded_width  >> !shift;
423
                int map = s->map[x];
424
425
                if (orig_mv_x >= -32) {
426
                    if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
427
                        x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
428
                        return AVERROR_INVALIDDATA;
429
430
                    copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
431
                                prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
432
                                frame->linesize[plane], prev->linesize[plane], 8);
433
                    if (map) {
434
                        s->idsp.idct(s->wblocks + x * 64);
435
                        for (int i = 0; i < 64; i++)
436
                            s->wblocks[i + x * 64] = (s->wblocks[i + x * 64] + 1) & 0xFFFC;
437
                        s->idsp.add_pixels_clamped(&s->wblocks[x*64], frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
438
                                                   frame->linesize[plane]);
439
                    }
440
                } else if (map) {
441
                    s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
442
                                     frame->linesize[plane], s->wblocks + x * 64);
443
                }
444
            }
445
        }
446
    } else if (s->flags & 2) {
447
        for (int y = 0; y < s->blocks_h; y++) {
448
            for (int x = 0; x < s->blocks_w; x++) {
449
                int shift = plane == 0;
450
                int mvpos = (y >> shift) * (s->blocks_w >> shift) + (x >> shift);
451
                int orig_mv_x = s->mvectors[mvpos].x;
452
                int mv_x = s->mvectors[mvpos].x / (1 + !shift);
453
                int mv_y = s->mvectors[mvpos].y / (1 + !shift);
454
                int h = s->avctx->coded_height >> !shift;
455
                int w = s->avctx->coded_width  >> !shift;
456
                int map = 0;
457
458
                ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
459
                if (ret < 0)
460
                    return ret;
461
462
                if (orig_mv_x >= -32) {
463
                    if (y * 8 + mv_y < 0 || y * 8 + mv_y + 8 > h ||
464
                        x * 8 + mv_x < 0 || x * 8 + mv_x + 8 > w)
465
                        return AVERROR_INVALIDDATA;
466
467
                    copy_block8(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
468
                                prev->data[plane] + ((s->blocks_h - 1 - y) * 8 - mv_y) * prev->linesize[plane] + (x * 8 + mv_x),
469
                                frame->linesize[plane], prev->linesize[plane], 8);
470
                    if (map) {
471
                        s->idsp.idct(s->block);
472
                        for (int i = 0; i < 64; i++)
473
                            s->block[i] = (s->block[i] + 1) & 0xFFFC;
474
                        s->idsp.add_pixels_clamped(s->block, frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
475
                                                   frame->linesize[plane]);
476
                    }
477
                } else if (map) {
478
                    s->idsp.idct_put(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
479
                                     frame->linesize[plane], s->block);
480
                }
481
            }
482
        }
483
    } else if (s->flags & 1) {
484
        av_fast_padded_malloc(&s->wblocks, &s->wblocks_size,
485
                              64 * s->blocks_w * sizeof(*s->wblocks));
486
        if (!s->wblocks)
487
            return AVERROR(ENOMEM);
488
489
        av_fast_padded_malloc(&s->map, &s->map_size,
490
                              s->blocks_w * sizeof(*s->map));
491
        if (!s->map)
492
            return AVERROR(ENOMEM);
493
494
        for (int y = 0; y < s->blocks_h; y++) {
495
            ret = decode_inter_blocks(s, gb, quant_matrix, &skip, s->map);
496
            if (ret < 0)
497
                return ret;
498
499
            for (int x = 0; x < s->blocks_w; x++) {
500
                if (!s->map[x])
501
                    continue;
502
                s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
503
                                 frame->linesize[plane], s->wblocks + 64 * x);
504
            }
505
        }
506
    } else {
507
        for (int y = 0; y < s->blocks_h; y++) {
508
            for (int x = 0; x < s->blocks_w; x++) {
509
                int map = 0;
510
511
                ret = decode_inter_block(s, gb, quant_matrix, &skip, &map);
512
                if (ret < 0)
513
                    return ret;
514
515
                if (!map)
516
                    continue;
517
                s->idsp.idct_add(frame->data[plane] + (s->blocks_h - 1 - y) * 8 * frame->linesize[plane] + x * 8,
518
                                 frame->linesize[plane], s->block);
519
            }
520
        }
521
    }
522
523
    align_get_bits(gb);
524
    if (get_bits_left(gb) < 0)
525
        av_log(s->avctx, AV_LOG_WARNING, "overread\n");
526
    if (get_bits_left(gb) > 0)
527
        av_log(s->avctx, AV_LOG_WARNING, "underread: %d\n", get_bits_left(gb));
528
529
    return 0;
530
}
531
532
static void compute_quant_matrix(AGMContext *s, double qscale)
533
{
534
    int luma[64], chroma[64];
535
    double f = 1.0 - fabs(qscale);
536
537
    if (!s->key_frame && (s->flags & 2)) {
538
        if (qscale >= 0.0) {
539
            for (int i = 0; i < 64; i++) {
540
                luma[i]   = FFMAX(1, 16 * f);
541
                chroma[i] = FFMAX(1, 16 * f);
542
            }
543
        } else {
544
            for (int i = 0; i < 64; i++) {
545
                luma[i]   = FFMAX(1, 16 - qscale * 32);
546
                chroma[i] = FFMAX(1, 16 - qscale * 32);
547
            }
548
        }
549
    } else {
550
        if (qscale >= 0.0) {
551
            for (int i = 0; i < 64; i++) {
552
                luma[i]   = FFMAX(1, unscaled_luma  [(i & 7) * 8 + (i >> 3)] * f);
553
                chroma[i] = FFMAX(1, unscaled_chroma[(i & 7) * 8 + (i >> 3)] * f);
554
            }
555
        } else {
556
            for (int i = 0; i < 64; i++) {
557
                luma[i]   = FFMAX(1, 255.0 - (255 - unscaled_luma  [(i & 7) * 8 + (i >> 3)]) * f);
558
                chroma[i] = FFMAX(1, 255.0 - (255 - unscaled_chroma[(i & 7) * 8 + (i >> 3)]) * f);
559
            }
560
        }
561
    }
562
563
    for (int i = 0; i < 64; i++) {
564
        int pos = ff_zigzag_direct[i];
565
566
        s->luma_quant_matrix[i]   = luma[pos]   * ((pos / 8) & 1 ? -1 : 1);
567
        s->chroma_quant_matrix[i] = chroma[pos] * ((pos / 8) & 1 ? -1 : 1);
568
    }
569
}
570
571
static int decode_raw_intra_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
572
{
573
    uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
574
    uint8_t r = 0, g = 0, b = 0;
575
576
    if (bytestream2_get_bytes_left(gbyte) < 3 * avctx->width * avctx->height)
577
        return AVERROR_INVALIDDATA;
578
579
    for (int y = 0; y < avctx->height; y++) {
580
        for (int x = 0; x < avctx->width; x++) {
581
            dst[x*3+0] = bytestream2_get_byteu(gbyte) + r;
582
            r = dst[x*3+0];
583
            dst[x*3+1] = bytestream2_get_byteu(gbyte) + g;
584
            g = dst[x*3+1];
585
            dst[x*3+2] = bytestream2_get_byteu(gbyte) + b;
586
            b = dst[x*3+2];
587
        }
588
        dst -= frame->linesize[0];
589
    }
590
591
    return 0;
592
}
593
594
av_always_inline static int fill_pixels(uint8_t **y0, uint8_t **y1,
595
                       uint8_t **u, uint8_t **v,
596
                       int ylinesize, int ulinesize, int vlinesize,
597
                       uint8_t *fill,
598
                       int *nx, int *ny, int *np, int w, int h)
599
{
600
    uint8_t *y0dst = *y0;
601
    uint8_t *y1dst = *y1;
602
    uint8_t *udst = *u;
603
    uint8_t *vdst = *v;
604
    int x = *nx, y = *ny, pos = *np;
605
606
    if (pos == 0) {
607
        y0dst[2*x+0] += fill[0];
608
        y0dst[2*x+1] += fill[1];
609
        y1dst[2*x+0] += fill[2];
610
        y1dst[2*x+1] += fill[3];
611
        pos++;
612
    } else if (pos == 1) {
613
        udst[x] += fill[0];
614
        vdst[x] += fill[1];
615
        x++;
616
        if (x >= w) {
617
            x = 0;
618
            y++;
619
            if (y >= h)
620
                return 1;
621
            y0dst -= 2*ylinesize;
622
            y1dst -= 2*ylinesize;
623
            udst  -=   ulinesize;
624
            vdst  -=   vlinesize;
625
        }
626
        y0dst[2*x+0] += fill[2];
627
        y0dst[2*x+1] += fill[3];
628
        pos++;
629
    } else if (pos == 2) {
630
        y1dst[2*x+0] += fill[0];
631
        y1dst[2*x+1] += fill[1];
632
        udst[x]      += fill[2];
633
        vdst[x]      += fill[3];
634
        x++;
635
        if (x >= w) {
636
            x = 0;
637
            y++;
638
            if (y >= h)
639
                return 1;
640
            y0dst -= 2*ylinesize;
641
            y1dst -= 2*ylinesize;
642
            udst  -=   ulinesize;
643
            vdst  -=   vlinesize;
644
        }
645
        pos = 0;
646
    }
647
648
    *y0 = y0dst;
649
    *y1 = y1dst;
650
    *u = udst;
651
    *v = vdst;
652
    *np = pos;
653
    *nx = x;
654
    *ny = y;
655
656
    return 0;
657
}
658
659
static int decode_runlen_rgb(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
660
{
661
    uint8_t *dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
662
    int runlen, y = 0, x = 0;
663
    uint8_t fill[4];
664
    unsigned code;
665
666
    while (bytestream2_get_bytes_left(gbyte) > 0) {
667
        code = bytestream2_peek_le32(gbyte);
668
        runlen = code & 0xFFFFFF;
669
670
        if (code >> 24 == 0x77) {
671
            bytestream2_skip(gbyte, 4);
672
673
            for (int i = 0; i < 4; i++)
674
                fill[i] = bytestream2_get_byte(gbyte);
675
676
            while (runlen > 0) {
677
                runlen--;
678
679
                for (int i = 0; i < 4; i++) {
680
                    dst[x] += fill[i];
681
                    x++;
682
                    if (x >= frame->width * 3) {
683
                        x = 0;
684
                        y++;
685
                        dst -= frame->linesize[0];
686
                        if (y >= frame->height)
687
                            return 0;
688
                    }
689
                }
690
            }
691
        } else {
692
            for (int i = 0; i < 4; i++)
693
                fill[i] = bytestream2_get_byte(gbyte);
694
695
            for (int i = 0; i < 4; i++) {
696
                dst[x] += fill[i];
697
                x++;
698
                if (x >= frame->width * 3) {
699
                    x = 0;
700
                    y++;
701
                    dst -= frame->linesize[0];
702
                    if (y >= frame->height)
703
                        return 0;
704
                }
705
            }
706
        }
707
    }
708
709
    return 0;
710
}
711
712
static int decode_runlen(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
713
{
714
    uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
715
    uint8_t *y1dst = y0dst - frame->linesize[0];
716
    uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
717
    uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
718
    int runlen, y = 0, x = 0, pos = 0;
719
    uint8_t fill[4];
720
    unsigned code;
721
722
    while (bytestream2_get_bytes_left(gbyte) > 0) {
723
        code = bytestream2_peek_le32(gbyte);
724
        runlen = code & 0xFFFFFF;
725
726
        if (code >> 24 == 0x77) {
727
            bytestream2_skip(gbyte, 4);
728
729
            for (int i = 0; i < 4; i++)
730
                fill[i] = bytestream2_get_byte(gbyte);
731
732
            while (runlen > 0) {
733
                runlen--;
734
735
                if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
736
                                frame->linesize[0],
737
                                frame->linesize[1],
738
                                frame->linesize[2],
739
                                fill, &x, &y, &pos,
740
                                avctx->width / 2,
741
                                avctx->height / 2))
742
                    return 0;
743
            }
744
        } else {
745
            for (int i = 0; i < 4; i++)
746
                fill[i] = bytestream2_get_byte(gbyte);
747
748
            if (fill_pixels(&y0dst, &y1dst, &udst, &vdst,
749
                            frame->linesize[0],
750
                            frame->linesize[1],
751
                            frame->linesize[2],
752
                            fill, &x, &y, &pos,
753
                            avctx->width / 2,
754
                            avctx->height / 2))
755
                return 0;
756
        }
757
    }
758
759
    return 0;
760
}
761
762
static int decode_raw_intra(AVCodecContext *avctx, GetByteContext *gbyte, AVFrame *frame)
763
{
764
    uint8_t *y0dst = frame->data[0] + (avctx->height - 1) * frame->linesize[0];
765
    uint8_t *y1dst = y0dst - frame->linesize[0];
766
    uint8_t *udst = frame->data[1] + ((avctx->height >> 1) - 1) * frame->linesize[1];
767
    uint8_t *vdst = frame->data[2] + ((avctx->height >> 1) - 1) * frame->linesize[2];
768
    uint8_t ly0 = 0, ly1 = 0, ly2 = 0, ly3 = 0, lu = 0, lv = 0;
769
770
    for (int y = 0; y < avctx->height / 2; y++) {
771
        for (int x = 0; x < avctx->width / 2; x++) {
772
            y0dst[x*2+0] = bytestream2_get_byte(gbyte) + ly0;
773
            ly0 = y0dst[x*2+0];
774
            y0dst[x*2+1] = bytestream2_get_byte(gbyte) + ly1;
775
            ly1 = y0dst[x*2+1];
776
            y1dst[x*2+0] = bytestream2_get_byte(gbyte) + ly2;
777
            ly2 = y1dst[x*2+0];
778
            y1dst[x*2+1] = bytestream2_get_byte(gbyte) + ly3;
779
            ly3 = y1dst[x*2+1];
780
            udst[x] = bytestream2_get_byte(gbyte) + lu;
781
            lu = udst[x];
782
            vdst[x] = bytestream2_get_byte(gbyte) + lv;
783
            lv = vdst[x];
784
        }
785
786
        y0dst -= 2*frame->linesize[0];
787
        y1dst -= 2*frame->linesize[0];
788
        udst  -= frame->linesize[1];
789
        vdst  -= frame->linesize[2];
790
    }
791
792
    return 0;
793
}
794
795
static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
796
{
797
    AGMContext *s = avctx->priv_data;
798
    int ret;
799
800
    compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
801
802
    s->blocks_w = avctx->coded_width  >> 3;
803
    s->blocks_h = avctx->coded_height >> 3;
804
805
    ret = decode_intra_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, 0);
806
    if (ret < 0)
807
        return ret;
808
809
    bytestream2_skip(&s->gbyte, s->size[0]);
810
811
    s->blocks_w = avctx->coded_width  >> 4;
812
    s->blocks_h = avctx->coded_height >> 4;
813
814
    ret = decode_intra_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, 2);
815
    if (ret < 0)
816
        return ret;
817
818
    bytestream2_skip(&s->gbyte, s->size[1]);
819
820
    s->blocks_w = avctx->coded_width  >> 4;
821
    s->blocks_h = avctx->coded_height >> 4;
822
823
    ret = decode_intra_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, 1);
824
    if (ret < 0)
825
        return ret;
826
827
    return 0;
828
}
829
830
static int decode_motion_vectors(AVCodecContext *avctx, GetBitContext *gb)
831
{
832
    AGMContext *s = avctx->priv_data;
833
    int nb_mvs = ((avctx->coded_height + 15) >> 4) * ((avctx->coded_width + 15) >> 4);
834
    int ret, skip = 0, value, map;
835
836
    av_fast_padded_malloc(&s->mvectors, &s->mvectors_size,
837
                          nb_mvs * sizeof(*s->mvectors));
838
    if (!s->mvectors)
839
        return AVERROR(ENOMEM);
840
841
    if ((ret = init_get_bits8(gb, s->gbyte.buffer, bytestream2_get_bytes_left(&s->gbyte) -
842
                                                   (s->size[0] + s->size[1] + s->size[2]))) < 0)
843
        return ret;
844
845
    memset(s->mvectors, 0, sizeof(*s->mvectors) * nb_mvs);
846
847
    for (int i = 0; i < nb_mvs; i++) {
848
        ret = read_code(gb, &skip, &value, &map, 1);
849
        if (ret < 0)
850
            return ret;
851
        s->mvectors[i].x = value;
852
        i += skip;
853
    }
854
855
    for (int i = 0; i < nb_mvs; i++) {
856
        ret = read_code(gb, &skip, &value, &map, 1);
857
        if (ret < 0)
858
            return ret;
859
        s->mvectors[i].y = value;
860
        i += skip;
861
    }
862
863
    if (get_bits_left(gb) <= 0)
864
        return AVERROR_INVALIDDATA;
865
    skip = (get_bits_count(gb) >> 3) + 1;
866
    bytestream2_skip(&s->gbyte, skip);
867
868
    return 0;
869
}
870
871
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
872
                        AVFrame *frame, AVFrame *prev)
873
{
874
    AGMContext *s = avctx->priv_data;
875
    int ret;
876
877
    compute_quant_matrix(s, (2 * s->compression - 100) / 100.0);
878
879
    if (s->flags & 2) {
880
        ret = decode_motion_vectors(avctx, gb);
881
        if (ret < 0)
882
            return ret;
883
    }
884
885
    s->blocks_w = avctx->coded_width  >> 3;
886
    s->blocks_h = avctx->coded_height >> 3;
887
888
    ret = decode_inter_plane(s, gb, s->size[0], s->luma_quant_matrix, frame, prev, 0);
889
    if (ret < 0)
890
        return ret;
891
892
    bytestream2_skip(&s->gbyte, s->size[0]);
893
894
    s->blocks_w = avctx->coded_width  >> 4;
895
    s->blocks_h = avctx->coded_height >> 4;
896
897
    ret = decode_inter_plane(s, gb, s->size[1], s->chroma_quant_matrix, frame, prev, 2);
898
    if (ret < 0)
899
        return ret;
900
901
    bytestream2_skip(&s->gbyte, s->size[1]);
902
903
    s->blocks_w = avctx->coded_width  >> 4;
904
    s->blocks_h = avctx->coded_height >> 4;
905
906
    ret = decode_inter_plane(s, gb, s->size[2], s->chroma_quant_matrix, frame, prev, 1);
907
    if (ret < 0)
908
        return ret;
909
910
    return 0;
911
}
912
913
typedef struct Node {
914
    int parent;
915
    int child[2];
916
} Node;
917
918
static void get_tree_codes(uint32_t *codes, Node *nodes, int idx, uint32_t pfx, int bitpos)
919
{
920
    if (idx < 256 && idx >= 0) {
921
        codes[idx] = pfx;
922
    } else if (idx >= 0) {
923
        get_tree_codes(codes, nodes, nodes[idx].child[0], pfx + (0 << bitpos), bitpos + 1);
924
        get_tree_codes(codes, nodes, nodes[idx].child[1], pfx + (1U << bitpos), bitpos + 1);
925
    }
926
}
927
928
static int make_new_tree(const uint8_t *bitlens, uint32_t *codes)
929
{
930
    int zlcount = 0, curlen, idx, nindex, last, llast;
931
    int blcounts[32] = { 0 };
932
    int syms[8192];
933
    Node nodes[512];
934
    int node_idx[1024];
935
    int old_idx[512];
936
937
    for (int i = 0; i < 256; i++) {
938
        int bitlen = bitlens[i];
939
        int blcount = blcounts[bitlen];
940
941
        zlcount += bitlen < 1;
942
        syms[(bitlen << 8) + blcount] = i;
943
        blcounts[bitlen]++;
944
    }
945
946
    for (int i = 0; i < 512; i++) {
947
        nodes[i].child[0] = -1;
948
        nodes[i].child[1] = -1;
949
    }
950
951
    for (int i = 0; i < 256; i++) {
952
        node_idx[i] = 257 + i;
953
    }
954
955
    curlen = 1;
956
    node_idx[512] = 256;
957
    last = 255;
958
    nindex = 1;
959
960
    for (curlen = 1; curlen < 32; curlen++) {
961
        if (blcounts[curlen] > 0) {
962
            int max_zlcount = zlcount + blcounts[curlen];
963
964
            for (int i = 0; zlcount < 256 && zlcount < max_zlcount; zlcount++, i++) {
965
                int p = node_idx[nindex - 1 + 512];
966
                int ch = syms[256 * curlen + i];
967
968
                if (nindex <= 0)
969
                    return AVERROR_INVALIDDATA;
970
971
                if (nodes[p].child[0] == -1) {
972
                    nodes[p].child[0] = ch;
973
                } else {
974
                    nodes[p].child[1] = ch;
975
                    nindex--;
976
                }
977
                nodes[ch].parent = p;
978
            }
979
        }
980
        llast = last - 1;
981
        idx = 0;
982
        while (nindex > 0) {
983
            int p, ch;
984
985
            last = llast - idx;
986
            p = node_idx[nindex - 1 + 512];
987
            ch = node_idx[last];
988
            if (nodes[p].child[0] == -1) {
989
                nodes[p].child[0] = ch;
990
            } else {
991
                nodes[p].child[1] = ch;
992
                nindex--;
993
            }
994
            old_idx[idx] = ch;
995
            nodes[ch].parent = p;
996
            if (idx == llast)
997
                goto next;
998
            idx++;
999
            if (nindex <= 0) {
1000
                for (int i = 0; i < idx; i++)
1001
                    node_idx[512 + i] = old_idx[i];
1002
            }
1003
        }
1004
        nindex = idx;
1005
    }
1006
1007
next:
1008
1009
    get_tree_codes(codes, nodes, 256, 0, 0);
1010
    return 0;
1011
}
1012
1013
static int build_huff(const uint8_t *bitlen, VLC *vlc)
1014
{
1015
    uint32_t new_codes[256];
1016
    uint8_t bits[256];
1017
    uint8_t symbols[256];
1018
    uint32_t codes[256];
1019
    int nb_codes = 0;
1020
1021
    int ret = make_new_tree(bitlen, new_codes);
1022
    if (ret < 0)
1023
        return ret;
1024
1025
    for (int i = 0; i < 256; i++) {
1026
        if (bitlen[i]) {
1027
            bits[nb_codes] = bitlen[i];
1028
            codes[nb_codes] = new_codes[i];
1029
            symbols[nb_codes] = i;
1030
            nb_codes++;
1031
        }
1032
    }
1033
1034
    ff_free_vlc(vlc);
1035
    return ff_init_vlc_sparse(vlc, 13, nb_codes,
1036
                              bits, 1, 1,
1037
                              codes, 4, 4,
1038
                              symbols, 1, 1,
1039
                              INIT_VLC_LE);
1040
}
1041
1042
static int decode_huffman2(AVCodecContext *avctx, int header, int size)
1043
{
1044
    AGMContext *s = avctx->priv_data;
1045
    GetBitContext *gb = &s->gb;
1046
    uint8_t lens[256];
1047
    int ret, x, len;
1048
1049
    if ((ret = init_get_bits8(gb, s->gbyte.buffer,
1050
                              bytestream2_get_bytes_left(&s->gbyte))) < 0)
1051
        return ret;
1052
1053
    s->output_size = get_bits_long(gb, 32);
1054
1055
    if (s->output_size > avctx->width * avctx->height * 9LL + 10000)
1056
        return AVERROR_INVALIDDATA;
1057
1058
    av_fast_padded_malloc(&s->output, &s->padded_output_size, s->output_size);
1059
    if (!s->output)
1060
        return AVERROR(ENOMEM);
1061
1062
    x = get_bits(gb, 1);
1063
    len = 4 + get_bits(gb, 1);
1064
    if (x) {
1065
        int cb[8] = { 0 };
1066
        int count = get_bits(gb, 3) + 1;
1067
1068
        for (int i = 0; i < count; i++)
1069
            cb[i] = get_bits(gb, len);
1070
1071
        for (int i = 0; i < 256; i++) {
1072
            int idx = get_bits(gb, 3);
1073
            lens[i] = cb[idx];
1074
        }
1075
    } else {
1076
        for (int i = 0; i < 256; i++)
1077
            lens[i] = get_bits(gb, len);
1078
    }
1079
1080
    if ((ret = build_huff(lens, &s->vlc)) < 0)
1081
        return ret;
1082
1083
    x = 0;
1084
    while (get_bits_left(gb) > 0 && x < s->output_size) {
1085
        int val = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
1086
        if (val < 0)
1087
            return AVERROR_INVALIDDATA;
1088
        s->output[x++] = val;
1089
    }
1090
1091
    return 0;
1092
}
1093
1094
static int decode_frame(AVCodecContext *avctx, void *data,
1095
                        int *got_frame, AVPacket *avpkt)
1096
{
1097
    AGMContext *s = avctx->priv_data;
1098
    GetBitContext *gb = &s->gb;
1099
    GetByteContext *gbyte = &s->gbyte;
1100
    AVFrame *frame = data;
1101
    int w, h, width, height, header;
1102
    unsigned compressed_size;
1103
    long skip;
1104
    int ret;
1105
1106
    if (!avpkt->size)
1107
        return 0;
1108
1109
    bytestream2_init(gbyte, avpkt->data, avpkt->size);
1110
1111
    header = bytestream2_get_le32(gbyte);
1112
    s->fflags = bytestream2_get_le32(gbyte);
1113
    s->bitstream_size = s->fflags & 0x1FFFFFFF;
1114
    s->fflags >>= 29;
1115
    av_log(avctx, AV_LOG_DEBUG, "fflags: %X\n", s->fflags);
1116
    if (avpkt->size < s->bitstream_size + 8)
1117
        return AVERROR_INVALIDDATA;
1118
1119
    s->key_frame = (avpkt->flags & AV_PKT_FLAG_KEY);
1120
    frame->key_frame = s->key_frame;
1121
    frame->pict_type = s->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
1122
1123
    if (!s->key_frame) {
1124
        if (!s->prev_frame->data[0]) {
1125
            av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1126
            return AVERROR_INVALIDDATA;
1127
        }
1128
    }
1129
1130
    if (header) {
1131
        if (avctx->codec_tag == MKTAG('A', 'G', 'M', '0') ||
1132
            avctx->codec_tag == MKTAG('A', 'G', 'M', '1'))
1133
            return AVERROR_PATCHWELCOME;
1134
        else
1135
            ret = decode_huffman2(avctx, header, (avpkt->size - s->bitstream_size) - 8);
1136
        if (ret < 0)
1137
            return ret;
1138
        bytestream2_init(gbyte, s->output, s->output_size);
1139
    } else if (!s->dct) {
1140
        bytestream2_skip(gbyte, 4);
1141
    }
1142
1143
    if (s->dct) {
1144
        s->flags = 0;
1145
        w = bytestream2_get_le32(gbyte);
1146
        h = bytestream2_get_le32(gbyte);
1147
        if (w == INT32_MIN || h == INT32_MIN)
1148
            return AVERROR_INVALIDDATA;
1149
        if (w < 0) {
1150
            w = -w;
1151
            s->flags |= 2;
1152
        }
1153
        if (h < 0) {
1154
            h = -h;
1155
            s->flags |= 1;
1156
        }
1157
1158
        width  = avctx->width;
1159
        height = avctx->height;
1160
        if (w < width || h < height || w & 7 || h & 7)
1161
            return AVERROR_INVALIDDATA;
1162
1163
        ret = ff_set_dimensions(avctx, w, h);
1164
        if (ret < 0)
1165
            return ret;
1166
        avctx->width = width;
1167
        avctx->height = height;
1168
1169
        s->compression = bytestream2_get_le32(gbyte);
1170
        if (s->compression < 0 || s->compression > 100)
1171
            return AVERROR_INVALIDDATA;
1172
1173
        for (int i = 0; i < 3; i++)
1174
            s->size[i] = bytestream2_get_le32(gbyte);
1175
        if (header) {
1176
            compressed_size = s->output_size;
1177
            skip = 8LL;
1178
        } else {
1179
            compressed_size = avpkt->size;
1180
            skip = 32LL;
1181
        }
1182
        if (s->size[0] < 0 || s->size[1] < 0 || s->size[2] < 0 ||
1183
            skip + s->size[0] + s->size[1] + s->size[2] > compressed_size) {
1184
            return AVERROR_INVALIDDATA;
1185
        }
1186
    }
1187
1188
    if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1189
        return ret;
1190
1191
    if (frame->key_frame) {
1192
        if (!s->dct && !s->rgb)
1193
            ret = decode_raw_intra(avctx, gbyte, frame);
1194
        else if (!s->dct && s->rgb)
1195
            ret = decode_raw_intra_rgb(avctx, gbyte, frame);
1196
        else
1197
            ret = decode_intra(avctx, gb, frame);
1198
    } else {
1199
        if (s->prev_frame-> width != frame->width ||
1200
            s->prev_frame->height != frame->height)
1201
            return AVERROR_INVALIDDATA;
1202
1203
        if (!(s->flags & 2)) {
1204
            ret = av_frame_copy(frame, s->prev_frame);
1205
            if (ret < 0)
1206
                return ret;
1207
        }
1208
1209
        if (s->dct) {
1210
            ret = decode_inter(avctx, gb, frame, s->prev_frame);
1211
        } else if (!s->dct && !s->rgb) {
1212
            ret = decode_runlen(avctx, gbyte, frame);
1213
        } else {
1214
            ret = decode_runlen_rgb(avctx, gbyte, frame);
1215
        }
1216
    }
1217
    if (ret < 0)
1218
        return ret;
1219
1220
    av_frame_unref(s->prev_frame);
1221
    if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
1222
        return ret;
1223
1224
    frame->crop_top  = avctx->coded_height - avctx->height;
1225
    frame->crop_left = avctx->coded_width  - avctx->width;
1226
1227
    *got_frame = 1;
1228
1229
    return avpkt->size;
1230
}
1231
1232
static av_cold int decode_init(AVCodecContext *avctx)
1233
{
1234
    AGMContext *s = avctx->priv_data;
1235
1236
    s->rgb = avctx->codec_tag == MKTAG('A', 'G', 'M', '4');
1237
    avctx->pix_fmt = s->rgb ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUV420P;
1238
    s->avctx = avctx;
1239
    s->plus = avctx->codec_tag == MKTAG('A', 'G', 'M', '3') ||
1240
              avctx->codec_tag == MKTAG('A', 'G', 'M', '7');
1241
1242
    s->dct = avctx->codec_tag != MKTAG('A', 'G', 'M', '4') &&
1243
             avctx->codec_tag != MKTAG('A', 'G', 'M', '5');
1244
1245
    if (!s->rgb && !s->dct) {
1246
        if ((avctx->width & 1) || (avctx->height & 1))
1247
            return AVERROR_INVALIDDATA;
1248
    }
1249
1250
    avctx->idct_algo = FF_IDCT_SIMPLE;
1251
    ff_idctdsp_init(&s->idsp, avctx);
1252
    ff_init_scantable(s->idsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1253
1254
    s->prev_frame = av_frame_alloc();
1255
    if (!s->prev_frame)
1256
        return AVERROR(ENOMEM);
1257
1258
    return 0;
1259
}
1260
1261
static void decode_flush(AVCodecContext *avctx)
1262
{
1263
    AGMContext *s = avctx->priv_data;
1264
1265
    av_frame_unref(s->prev_frame);
1266
}
1267
1268
static av_cold int decode_close(AVCodecContext *avctx)
1269
{
1270
    AGMContext *s = avctx->priv_data;
1271
1272
    ff_free_vlc(&s->vlc);
1273
    av_frame_free(&s->prev_frame);
1274
    av_freep(&s->mvectors);
1275
    s->mvectors_size = 0;
1276
    av_freep(&s->wblocks);
1277
    s->wblocks_size = 0;
1278
    av_freep(&s->output);
1279
    s->padded_output_size = 0;
1280
    av_freep(&s->map);
1281
    s->map_size = 0;
1282
1283
    return 0;
1284
}
1285
1286
AVCodec ff_agm_decoder = {
1287
    .name             = "agm",
1288
    .long_name        = NULL_IF_CONFIG_SMALL("Amuse Graphics Movie"),
1289
    .type             = AVMEDIA_TYPE_VIDEO,
1290
    .id               = AV_CODEC_ID_AGM,
1291
    .priv_data_size   = sizeof(AGMContext),
1292
    .init             = decode_init,
1293
    .close            = decode_close,
1294
    .decode           = decode_frame,
1295
    .flush            = decode_flush,
1296
    .capabilities     = AV_CODEC_CAP_DR1,
1297
    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
1298
                        FF_CODEC_CAP_INIT_CLEANUP |
1299
                        FF_CODEC_CAP_EXPORTS_CROPPING,
1300
};