GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mv30.c Lines: 0 403 0.0 %
Date: 2020-10-23 17:01:47 Branches: 0 144 0.0 %

Line Branch Exec Source
1
/*
2
 * MidiVid MV30 decoder
3
 *
4
 * Copyright (c) 2020 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
#include "libavutil/thread.h"
28
29
#include "avcodec.h"
30
#include "bytestream.h"
31
#include "copy_block.h"
32
#include "mathops.h"
33
#include "blockdsp.h"
34
#include "get_bits.h"
35
#include "internal.h"
36
#include "aandcttab.h"
37
38
typedef struct MV30Context {
39
    GetBitContext  gb;
40
41
    int intra_quant;
42
    int inter_quant;
43
    int is_inter;
44
    int mode_size;
45
    int nb_mvectors;
46
47
    int      block[6][64];
48
    int16_t *mvectors;
49
    unsigned int mvectors_size;
50
    int16_t *coeffs;
51
    unsigned int coeffs_size;
52
53
    int16_t intraq_tab[2][64];
54
    int16_t interq_tab[2][64];
55
56
    BlockDSPContext bdsp;
57
    AVFrame *prev_frame;
58
} MV30Context;
59
60
static VLC cbp_tab;
61
62
static const uint8_t luma_tab[] = {
63
    12, 12, 15, 19, 25, 34, 40, 48,
64
    12, 12, 18, 22, 27, 44, 47, 46,
65
    17, 18, 21, 26, 35, 46, 52, 47,
66
    18, 20, 24, 28, 40, 61, 59, 51,
67
    20, 24, 32, 43, 50, 72, 72, 63,
68
    25, 31, 42, 48, 58, 72, 81, 75,
69
    38, 46, 54, 61, 71, 84, 88, 85,
70
    50, 61, 65, 68, 79, 78, 86, 91,
71
};
72
73
static const uint8_t chroma_tab[] = {
74
    12, 16, 24, 47, 99, 99, 99, 99,
75
    16, 21, 26, 66, 99, 99, 99, 99,
76
    24, 26, 56, 99, 99, 99, 99, 99,
77
    47, 66, 99, 99, 99, 99, 99, 99,
78
    99, 99, 99, 99, 99, 99, 99, 99,
79
    99, 99, 99, 99, 99, 99, 99, 99,
80
    99, 99, 99, 99, 99, 99, 99, 99,
81
    99, 99, 99, 99, 99, 99, 99, 99,
82
};
83
84
static const uint8_t zigzag[] = {
85
     0,  1,  8,  9, 16,  2,  3, 10,
86
    17, 24, 32, 25, 18, 11,  4,  5,
87
    12, 19, 26, 33, 40, 48, 41, 34,
88
    27, 20, 13,  6,  7, 14, 21, 28,
89
    35, 42, 49, 56, 57, 50, 43, 36,
90
    29, 22, 15, 23, 30, 37, 44, 51,
91
    58, 59, 52, 45, 38, 31, 39, 46,
92
    53, 60, 61, 54, 47, 55, 62, 63,
93
};
94
95
static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
96
{
97
    int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2;
98
99
    for (int i = 0; i < 64; i++) {
100
        table[i] = av_clip((quant_tab[i] * factor + 0x32) / 100, 1, 0x7fff);
101
        table[i] = ((int)ff_aanscales[i] * (int)table[i] + 0x800) >> 12;
102
    }
103
}
104
105
static inline void idct_1d(int *blk, int step)
106
{
107
    const unsigned t0 = blk[0 * step] + blk[4 * step];
108
    const unsigned t1 = blk[0 * step] - blk[4 * step];
109
    const unsigned t2 = blk[2 * step] + blk[6 * step];
110
    const unsigned t3 = ((int)((blk[2 * step] - blk[6 * step]) * 362U) >> 8) - t2;
111
    const unsigned t4 = t0 + t2;
112
    const unsigned t5 = t0 - t2;
113
    const unsigned t6 = t1 + t3;
114
    const unsigned t7 = t1 - t3;
115
    const unsigned t8 = blk[5 * step] + blk[3 * step];
116
    const unsigned t9 = blk[5 * step] - blk[3 * step];
117
    const unsigned tA = blk[1 * step] + blk[7 * step];
118
    const unsigned tB = blk[1 * step] - blk[7 * step];
119
    const unsigned tC = t8 + tA;
120
    const unsigned tD = (int)((tB + t9) * 473U) >> 8;
121
    const unsigned tE = (((int)(t9 * -669U) >> 8) - tC) + tD;
122
    const unsigned tF = ((int)((tA - t8) * 362U) >> 8) - tE;
123
    const unsigned t10 = (((int)(tB * 277U) >> 8) - tD) + tF;
124
125
    blk[0 * step] = t4 + tC;
126
    blk[1 * step] = t6 + tE;
127
    blk[2 * step] = t7 + tF;
128
    blk[3 * step] = t5 - t10;
129
    blk[4 * step] = t5 + t10;
130
    blk[5 * step] = t7 - tF;
131
    blk[6 * step] = t6 - tE;
132
    blk[7 * step] = t4 - tC;
133
}
134
135
static void idct_put(uint8_t *dst, int stride, int *block)
136
{
137
    for (int i = 0; i < 8; i++) {
138
        if ((block[0x08 + i] |
139
             block[0x10 + i] |
140
             block[0x18 + i] |
141
             block[0x20 + i] |
142
             block[0x28 + i] |
143
             block[0x30 + i] |
144
             block[0x38 + i]) == 0) {
145
            block[0x08 + i] = block[i];
146
            block[0x10 + i] = block[i];
147
            block[0x18 + i] = block[i];
148
            block[0x20 + i] = block[i];
149
            block[0x28 + i] = block[i];
150
            block[0x30 + i] = block[i];
151
            block[0x38 + i] = block[i];
152
        } else {
153
            idct_1d(block + i, 8);
154
        }
155
    }
156
157
    for (int i = 0; i < 8; i++) {
158
        idct_1d(block, 1);
159
        for (int j = 0; j < 8; j++)
160
            dst[j] = av_clip_uint8((block[j] >> 5) + 128);
161
        block += 8;
162
        dst += stride;
163
    }
164
}
165
166
static void idct_add(uint8_t *dst, int stride,
167
                     const uint8_t *src, int in_linesize, int *block)
168
{
169
    for (int i = 0; i < 8; i++) {
170
        if ((block[0x08 + i] |
171
             block[0x10 + i] |
172
             block[0x18 + i] |
173
             block[0x20 + i] |
174
             block[0x28 + i] |
175
             block[0x30 + i] |
176
             block[0x38 + i]) == 0) {
177
            block[0x08 + i] = block[i];
178
            block[0x10 + i] = block[i];
179
            block[0x18 + i] = block[i];
180
            block[0x20 + i] = block[i];
181
            block[0x28 + i] = block[i];
182
            block[0x30 + i] = block[i];
183
            block[0x38 + i] = block[i];
184
        } else {
185
            idct_1d(block + i, 8);
186
        }
187
    }
188
189
    for (int i = 0; i < 8; i++) {
190
        idct_1d(block, 1);
191
        for (int j = 0; j < 8; j++)
192
            dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
193
        block += 8;
194
        dst += stride;
195
        src += in_linesize;
196
    }
197
}
198
199
static inline void idct2_1d(int *blk, int step)
200
{
201
    const unsigned int  t0 = blk[0 * step];
202
    const unsigned int t1 = blk[1 * step];
203
    const unsigned int t2 = (int)(t1 * 473U) >> 8;
204
    const unsigned int t3 = t2 - t1;
205
    const unsigned int t4 =  ((int)(t1 * 362U) >> 8) - t3;
206
    const unsigned int t5 = (((int)(t1 * 277U) >> 8) - t2) + t4;
207
208
    blk[0 * step] = t1 + t0;
209
    blk[1 * step] = t0 + t3;
210
    blk[2 * step] = t4 + t0;
211
    blk[3 * step] = t0 - t5;
212
    blk[4 * step] = t5 + t0;
213
    blk[5 * step] = t0 - t4;
214
    blk[6 * step] = t0 - t3;
215
    blk[7 * step] = t0 - t1;
216
}
217
218
static void idct2_put(uint8_t *dst, int stride, int *block)
219
{
220
    for (int i = 0; i < 2; i++) {
221
        if ((block[0x08 + i]) == 0) {
222
            block[0x08 + i] = block[i];
223
            block[0x10 + i] = block[i];
224
            block[0x18 + i] = block[i];
225
            block[0x20 + i] = block[i];
226
            block[0x28 + i] = block[i];
227
            block[0x30 + i] = block[i];
228
            block[0x38 + i] = block[i];
229
        } else {
230
            idct2_1d(block + i, 8);
231
        }
232
    }
233
234
    for (int i = 0; i < 8; i++) {
235
        if (block[1] == 0) {
236
            for (int j = 0; j < 8; j++)
237
                dst[j] = av_clip_uint8((block[0] >> 5) + 128);
238
        } else {
239
            idct2_1d(block, 1);
240
            for (int j = 0; j < 8; j++)
241
                dst[j] = av_clip_uint8((block[j] >> 5) + 128);
242
        }
243
        block += 8;
244
        dst += stride;
245
    }
246
}
247
248
static void idct2_add(uint8_t *dst, int stride,
249
                      const uint8_t *src, int in_linesize,
250
                      int *block)
251
{
252
    for (int i = 0; i < 2; i++) {
253
        if ((block[0x08 + i]) == 0) {
254
            block[0x08 + i] = block[i];
255
            block[0x10 + i] = block[i];
256
            block[0x18 + i] = block[i];
257
            block[0x20 + i] = block[i];
258
            block[0x28 + i] = block[i];
259
            block[0x30 + i] = block[i];
260
            block[0x38 + i] = block[i];
261
        } else {
262
            idct2_1d(block + i, 8);
263
        }
264
    }
265
266
    for (int i = 0; i < 8; i++) {
267
        if (block[1] == 0) {
268
            for (int j = 0; j < 8; j++)
269
                dst[j] = av_clip_uint8((block[0] >> 5) + src[j]);
270
        } else {
271
            idct2_1d(block, 1);
272
            for (int j = 0; j < 8; j++)
273
                dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
274
        }
275
        block += 8;
276
        dst += stride;
277
        src += in_linesize;
278
    }
279
}
280
281
static void update_inter_block(uint8_t *dst, int stride,
282
                               const uint8_t *src, int in_linesize,
283
                               int block)
284
{
285
    for (int i = 0; i < 8; i++) {
286
        for (int j = 0; j < 8; j++)
287
            dst[j] = av_clip_uint8(block + src[j]);
288
        dst += stride;
289
        src += in_linesize;
290
    }
291
}
292
293
static int decode_intra_block(AVCodecContext *avctx, int mode,
294
                              GetByteContext *gbyte, int16_t *qtab,
295
                              int *block, int *pfill,
296
                              uint8_t *dst, int linesize)
297
{
298
    MV30Context *s = avctx->priv_data;
299
    int fill;
300
301
    switch (mode) {
302
    case 0:
303
        s->bdsp.fill_block_tab[1](dst, 128, linesize, 8);
304
        break;
305
    case 1:
306
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
307
        pfill[0] += fill;
308
        block[0] = ((int)((unsigned)pfill[0] * qtab[0]) >> 5) + 128;
309
        s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8);
310
        break;
311
    case 2:
312
        memset(block, 0, sizeof(*block) * 64);
313
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
314
        pfill[0] += fill;
315
        block[0] = (unsigned)pfill[0] * qtab[0];
316
        block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
317
        block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
318
        block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
319
        idct2_put(dst, linesize, block);
320
        break;
321
    case 3:
322
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
323
        pfill[0] += fill;
324
        block[0] = (unsigned)pfill[0] * qtab[0];
325
        for (int i = 1; i < 64; i++)
326
            block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
327
        idct_put(dst, linesize, block);
328
        break;
329
    }
330
331
    return 0;
332
}
333
334
static int decode_inter_block(AVCodecContext *avctx, int mode,
335
                              GetByteContext *gbyte, int16_t *qtab,
336
                              int *block, int *pfill,
337
                              uint8_t *dst, int linesize,
338
                              const uint8_t *src, int in_linesize)
339
{
340
    int fill;
341
342
    switch (mode) {
343
    case 0:
344
        copy_block8(dst, src, linesize, in_linesize, 8);
345
        break;
346
    case 1:
347
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
348
        pfill[0] += fill;
349
        block[0] = (int)((unsigned)pfill[0] * qtab[0]) >> 5;
350
        update_inter_block(dst, linesize, src, in_linesize, block[0]);
351
        break;
352
    case 2:
353
        memset(block, 0, sizeof(*block) * 64);
354
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
355
        pfill[0] += fill;
356
        block[0] = (unsigned)pfill[0] * qtab[0];
357
        block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
358
        block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
359
        block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
360
        idct2_add(dst, linesize, src, in_linesize, block);
361
        break;
362
    case 3:
363
        fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
364
        pfill[0] += fill;
365
        block[0] = (unsigned)pfill[0] * qtab[0];
366
        for (int i = 1; i < 64; i++)
367
            block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
368
        idct_add(dst, linesize, src, in_linesize, block);
369
        break;
370
    }
371
372
    return 0;
373
}
374
375
static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
376
{
377
    memset(coeffs, 0, nb_codes * sizeof(*coeffs));
378
379
    for (int i = 0; i < nb_codes;) {
380
        int value = get_vlc2(gb, cbp_tab.table, cbp_tab.bits, 1);
381
382
        if (value < 0)
383
            return AVERROR_INVALIDDATA;
384
385
        if (value > 0) {
386
            int x = get_bits(gb, value);
387
388
            if (x < (1 << value) / 2) {
389
                x =  (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1));
390
            } else {
391
                x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1));
392
            }
393
            coeffs[i++] = x;
394
        } else {
395
            int flag = get_bits1(gb);
396
397
            i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8;
398
        }
399
    }
400
401
    return 0;
402
}
403
404
static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
405
{
406
    MV30Context *s = avctx->priv_data;
407
    GetBitContext mgb;
408
    uint8_t *dst[6];
409
    int linesize[6];
410
    int ret;
411
412
    mgb = *gb;
413
    if (get_bits_left(gb) < s->mode_size * 8)
414
        return AVERROR_INVALIDDATA;
415
416
    skip_bits_long(gb, s->mode_size * 8);
417
418
    linesize[0] = frame->linesize[0];
419
    linesize[1] = frame->linesize[0];
420
    linesize[2] = frame->linesize[0];
421
    linesize[3] = frame->linesize[0];
422
    linesize[4] = frame->linesize[1];
423
    linesize[5] = frame->linesize[2];
424
425
    for (int y = 0; y < avctx->height; y += 16) {
426
        GetByteContext gbyte;
427
        int pfill[3][1] = { {0} };
428
        int nb_codes = get_bits(gb, 16);
429
430
        av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
431
        if (!s->coeffs)
432
            return AVERROR(ENOMEM);
433
        ret = decode_coeffs(gb, s->coeffs, nb_codes);
434
        if (ret < 0)
435
            return ret;
436
437
        bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
438
439
        for (int x = 0; x < avctx->width; x += 16) {
440
            dst[0] = frame->data[0] + linesize[0] * y + x;
441
            dst[1] = frame->data[0] + linesize[0] * y + x + 8;
442
            dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
443
            dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
444
            dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
445
            dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
446
447
            for (int b = 0; b < 6; b++) {
448
                int mode = get_bits_le(&mgb, 2);
449
450
                ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
451
                                         s->block[b],
452
                                         pfill[(b >= 4) + (b >= 5)],
453
                                         dst[b], linesize[b]);
454
                if (ret < 0)
455
                    return ret;
456
            }
457
        }
458
    }
459
460
    return 0;
461
}
462
463
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
464
                        AVFrame *frame, AVFrame *prev)
465
{
466
    MV30Context *s = avctx->priv_data;
467
    GetBitContext mask;
468
    GetBitContext mgb;
469
    GetByteContext mv;
470
    const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;
471
    uint8_t *dst[6], *src[6];
472
    int in_linesize[6];
473
    int linesize[6];
474
    int ret, cnt = 0;
475
    int flags = 0;
476
477
    in_linesize[0] = prev->linesize[0];
478
    in_linesize[1] = prev->linesize[0];
479
    in_linesize[2] = prev->linesize[0];
480
    in_linesize[3] = prev->linesize[0];
481
    in_linesize[4] = prev->linesize[1];
482
    in_linesize[5] = prev->linesize[2];
483
484
    linesize[0] = frame->linesize[0];
485
    linesize[1] = frame->linesize[0];
486
    linesize[2] = frame->linesize[0];
487
    linesize[3] = frame->linesize[0];
488
    linesize[4] = frame->linesize[1];
489
    linesize[5] = frame->linesize[2];
490
491
    av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));
492
    if (!s->mvectors) {
493
        ret = AVERROR(ENOMEM);
494
        goto fail;
495
    }
496
497
    mask = *gb;
498
    skip_bits_long(gb, mask_size * 8);
499
    mgb = *gb;
500
    skip_bits_long(gb, s->mode_size * 8);
501
502
    ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);
503
    if (ret < 0)
504
        goto fail;
505
506
    bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));
507
508
    for (int y = 0; y < avctx->height; y += 16) {
509
        GetByteContext gbyte;
510
        int pfill[3][1] = { {0} };
511
        int nb_codes = get_bits(gb, 16);
512
513
        skip_bits(gb, 8);
514
        if (get_bits_left(gb) < 0) {
515
            ret = AVERROR_INVALIDDATA;
516
            goto fail;
517
        }
518
519
        av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
520
        if (!s->coeffs) {
521
            ret = AVERROR(ENOMEM);
522
            goto fail;
523
        }
524
525
        ret = decode_coeffs(gb, s->coeffs, nb_codes);
526
        if (ret < 0)
527
            goto fail;
528
529
        bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
530
531
        for (int x = 0; x < avctx->width; x += 16) {
532
            if (cnt >= 4)
533
                cnt = 0;
534
            if (cnt == 0) {
535
                if (get_bits_left(&mask) < 8) {
536
                    ret = AVERROR_INVALIDDATA;
537
                    goto fail;
538
                }
539
                flags = get_bits(&mask, 8);
540
            }
541
542
            dst[0] = frame->data[0] + linesize[0] * y + x;
543
            dst[1] = frame->data[0] + linesize[0] * y + x + 8;
544
            dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
545
            dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
546
            dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
547
            dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
548
549
            if ((flags >> (cnt)) & 1) {
550
                int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);
551
                int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);
552
553
                int px = x + mv_x;
554
                int py = y + mv_y;
555
556
                if (px < 0 || px > FFALIGN(avctx->width , 16) - 16 ||
557
                    py < 0 || py > FFALIGN(avctx->height, 16) - 16)
558
                    return AVERROR_INVALIDDATA;
559
560
                src[0] = prev->data[0] + in_linesize[0] * py + px;
561
                src[1] = prev->data[0] + in_linesize[0] * py + px + 8;
562
                src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;
563
                src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;
564
                src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);
565
                src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);
566
567
                if ((flags >> (cnt + 4)) & 1) {
568
                    for (int b = 0; b < 6; b++)
569
                        copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);
570
                } else {
571
                    for (int b = 0; b < 6; b++) {
572
                        int mode = get_bits_le(&mgb, 2);
573
574
                        ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],
575
                                                 s->block[b],
576
                                                 pfill[(b >= 4) + (b >= 5)],
577
                                                 dst[b], linesize[b],
578
                                                 src[b], in_linesize[b]);
579
                        if (ret < 0)
580
                            goto fail;
581
                    }
582
                }
583
            } else {
584
                for (int b = 0; b < 6; b++) {
585
                    int mode = get_bits_le(&mgb, 2);
586
587
                    ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
588
                                             s->block[b],
589
                                             pfill[(b >= 4) + (b >= 5)],
590
                                             dst[b], linesize[b]);
591
                    if (ret < 0)
592
                        goto fail;
593
                }
594
            }
595
596
            cnt++;
597
        }
598
    }
599
600
fail:
601
    return ret;
602
}
603
604
static int decode_frame(AVCodecContext *avctx, void *data,
605
                        int *got_frame, AVPacket *avpkt)
606
{
607
    MV30Context *s = avctx->priv_data;
608
    GetBitContext *gb = &s->gb;
609
    AVFrame *frame = data;
610
    int ret;
611
612
    if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
613
        return ret;
614
615
    if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
616
        return ret;
617
618
    s->intra_quant = get_bits(gb, 8);
619
    s->inter_quant = s->intra_quant + get_sbits(gb, 8);
620
    s->is_inter = get_bits_le(gb, 16);
621
    s->mode_size = get_bits_le(gb, 16);
622
    if (s->is_inter)
623
        s->nb_mvectors = get_bits_le(gb, 16);
624
625
    get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);
626
    get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);
627
628
    frame->key_frame = s->is_inter == 0;
629
630
    if (frame->key_frame) {
631
        ret = decode_intra(avctx, gb, frame);
632
        if (ret < 0)
633
            return ret;
634
    } else {
635
        get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);
636
        get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);
637
638
        if (!s->prev_frame->data[0]) {
639
            av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
640
            return AVERROR_INVALIDDATA;
641
        }
642
643
        ret = decode_inter(avctx, gb, frame, s->prev_frame);
644
        if (ret < 0)
645
            return ret;
646
    }
647
648
    av_frame_unref(s->prev_frame);
649
    if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
650
        return ret;
651
652
    *got_frame = 1;
653
654
    return avpkt->size;
655
}
656
657
static const uint16_t cbp_codes[] = {
658
    0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF,
659
};
660
661
static const uint8_t cbp_bits[] = {
662
    2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,
663
};
664
665
static av_cold void init_static_data(void)
666
{
667
    INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits),
668
                           cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512);
669
}
670
671
static av_cold int decode_init(AVCodecContext *avctx)
672
{
673
    MV30Context *s = avctx->priv_data;
674
    static AVOnce init_static_once = AV_ONCE_INIT;
675
676
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
677
    avctx->color_range = AVCOL_RANGE_JPEG;
678
679
    ff_blockdsp_init(&s->bdsp, avctx);
680
681
    s->prev_frame = av_frame_alloc();
682
    if (!s->prev_frame)
683
        return AVERROR(ENOMEM);
684
685
    ff_thread_once(&init_static_once, init_static_data);
686
687
    return 0;
688
}
689
690
static void decode_flush(AVCodecContext *avctx)
691
{
692
    MV30Context *s = avctx->priv_data;
693
694
    av_frame_unref(s->prev_frame);
695
}
696
697
static av_cold int decode_close(AVCodecContext *avctx)
698
{
699
    MV30Context *s = avctx->priv_data;
700
701
    av_frame_free(&s->prev_frame);
702
    av_freep(&s->coeffs);
703
    s->coeffs_size = 0;
704
    av_freep(&s->mvectors);
705
    s->mvectors_size = 0;
706
707
    return 0;
708
}
709
710
AVCodec ff_mv30_decoder = {
711
    .name             = "mv30",
712
    .long_name        = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
713
    .type             = AVMEDIA_TYPE_VIDEO,
714
    .id               = AV_CODEC_ID_MV30,
715
    .priv_data_size   = sizeof(MV30Context),
716
    .init             = decode_init,
717
    .close            = decode_close,
718
    .decode           = decode_frame,
719
    .flush            = decode_flush,
720
    .capabilities     = AV_CODEC_CAP_DR1,
721
    .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
722
                        FF_CODEC_CAP_INIT_CLEANUP,
723
};