GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/asvdec.c Lines: 142 158 89.9 %
Date: 2021-01-26 11:44:58 Branches: 76 94 80.9 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2003 Michael Niedermayer
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
/**
22
 * @file
23
 * ASUS V1/V2 decoder.
24
 */
25
26
#include "libavutil/attributes.h"
27
#include "libavutil/mem.h"
28
#include "libavutil/thread.h"
29
30
#include "asv.h"
31
#include "avcodec.h"
32
#include "blockdsp.h"
33
#include "idctdsp.h"
34
#include "internal.h"
35
#include "mpeg12data.h"
36
37
#define CCP_VLC_BITS         5
38
#define DC_CCP_VLC_BITS      4
39
#define AC_CCP_VLC_BITS      6
40
#define ASV1_LEVEL_VLC_BITS  4
41
#define ASV2_LEVEL_VLC_BITS 10
42
43
static VLC ccp_vlc;
44
static VLC level_vlc;
45
static VLC dc_ccp_vlc;
46
static VLC ac_ccp_vlc;
47
static VLC asv2_level_vlc;
48
49
10
static av_cold void init_vlcs(void)
50
{
51
10
    INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17,
52
                    &ff_asv_ccp_tab[0][1], 2, 1,
53
                    &ff_asv_ccp_tab[0][0], 2, 1, 32);
54
10
    INIT_LE_VLC_STATIC(&dc_ccp_vlc, DC_CCP_VLC_BITS, 8,
55
                       &ff_asv_dc_ccp_tab[0][1], 2, 1,
56
                       &ff_asv_dc_ccp_tab[0][0], 2, 1, 16);
57
10
    INIT_LE_VLC_STATIC(&ac_ccp_vlc, AC_CCP_VLC_BITS, 16,
58
                       &ff_asv_ac_ccp_tab[0][1], 2, 1,
59
                       &ff_asv_ac_ccp_tab[0][0], 2, 1, 64);
60
10
    INIT_VLC_STATIC(&level_vlc, ASV1_LEVEL_VLC_BITS, 7,
61
                    &ff_asv_level_tab[0][1], 2, 1,
62
                    &ff_asv_level_tab[0][0], 2, 1, 16);
63
10
    INIT_LE_VLC_STATIC(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63,
64
                       &ff_asv2_level_tab[0][1], 4, 2,
65
                       &ff_asv2_level_tab[0][0], 4, 2, 1024);
66
10
}
67
68
2972884
static inline int asv1_get_level(GetBitContext *gb)
69
{
70
2972884
    int code = get_vlc2(gb, level_vlc.table, ASV1_LEVEL_VLC_BITS, 1);
71
72
2972884
    if (code == 3)
73
429712
        return get_sbits(gb, 8);
74
    else
75
2543172
        return code - 3;
76
}
77
78
// get_vlc2() is big-endian in this file
79
6010437
static inline int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE (*table)[2], int bits)
80
{
81
    unsigned int index;
82
    int code, n;
83
84
6010437
    OPEN_READER(re, gb);
85
6010437
    UPDATE_CACHE_LE(re, gb);
86
87
6010437
    index = SHOW_UBITS_LE(re, gb, bits);
88
6010437
    code  = table[index][0];
89
6010437
    n     = table[index][1];
90
6010437
    LAST_SKIP_BITS(re, gb, n);
91
92
6010437
    CLOSE_READER(re, gb);
93
94
6010437
    return code;
95
}
96
97
3660409
static inline int asv2_get_level(GetBitContext *gb)
98
{
99
3660409
    int code = asv2_get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS);
100
101
3660409
    if (code == 31)
102
613
        return (int8_t) get_bits_le(gb, 8);
103
    else
104
3659796
        return code - 31;
105
}
106
107
359100
static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])
108
{
109
    int i;
110
111
359100
    block[0] = 8 * get_bits(&a->gb, 8);
112
113
2128752
    for (i = 0; i < 11; i++) {
114
2128752
        const int ccp = get_vlc2(&a->gb, ccp_vlc.table, CCP_VLC_BITS, 1);
115
116
2128752
        if (ccp) {
117
1723494
            if (ccp == 16)
118
359100
                break;
119

1364394
            if (ccp < 0 || i >= 10) {
120
                av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");
121
                return AVERROR_INVALIDDATA;
122
            }
123
124
1364394
            if (ccp & 8)
125
759471
                block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
126
1364394
            if (ccp & 4)
127
828513
                block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
128
1364394
            if (ccp & 2)
129
781213
                block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
130
1364394
            if (ccp & 1)
131
603687
                block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
132
        }
133
    }
134
135
359100
    return 0;
136
}
137
138
359100
static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])
139
{
140
    int i, count, ccp;
141
142
359100
    count = get_bits_le(&a->gb, 4);
143
144
359100
    block[0] = 8 * get_bits_le(&a->gb, 8);
145
146
359100
    ccp = asv2_get_vlc2(&a->gb, dc_ccp_vlc.table, DC_CCP_VLC_BITS);
147
359100
    if (ccp) {
148
329075
        if (ccp & 4)
149
281504
            block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;
150
329075
        if (ccp & 2)
151
284503
            block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;
152
329075
        if (ccp & 1)
153
226812
            block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;
154
    }
155
156
2350028
    for (i = 1; i < count + 1; i++) {
157
1990928
        const int ccp = asv2_get_vlc2(&a->gb, ac_ccp_vlc.table, AC_CCP_VLC_BITS);
158
159
1990928
        if (ccp) {
160
1368743
            if (ccp & 8)
161
968959
                block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;
162
1368743
            if (ccp & 4)
163
733048
                block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;
164
1368743
            if (ccp & 2)
165
667011
                block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;
166
1368743
            if (ccp & 1)
167
498572
                block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;
168
        }
169
    }
170
171
359100
    return 0;
172
}
173
174
119700
static inline int decode_mb(ASV1Context *a, int16_t block[6][64])
175
{
176
    int i, ret;
177
178
119700
    a->bdsp.clear_blocks(block[0]);
179
180
119700
    if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
181
418950
        for (i = 0; i < 6; i++) {
182
359100
            if ((ret = asv1_decode_block(a, block[i])) < 0)
183
                return ret;
184
        }
185
    } else {
186
418950
        for (i = 0; i < 6; i++) {
187
359100
            if ((ret = asv2_decode_block(a, block[i])) < 0)
188
                return ret;
189
        }
190
    }
191
119700
    return 0;
192
}
193
194
119700
static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)
195
{
196
119700
    int16_t(*block)[64] = a->block;
197
119700
    int linesize = frame->linesize[0];
198
199
119700
    uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;
200
119700
    uint8_t *dest_cb = frame->data[1] + (mb_y *  8 * frame->linesize[1]) + mb_x *  8;
201
119700
    uint8_t *dest_cr = frame->data[2] + (mb_y *  8 * frame->linesize[2]) + mb_x *  8;
202
203
119700
    a->idsp.idct_put(dest_y,                    linesize, block[0]);
204
119700
    a->idsp.idct_put(dest_y + 8,                linesize, block[1]);
205
119700
    a->idsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);
206
119700
    a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);
207
208
119700
    if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
209
119700
        a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);
210
119700
        a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);
211
    }
212
119700
}
213
214
400
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
215
                        AVPacket *avpkt)
216
{
217
400
    ASV1Context *const a = avctx->priv_data;
218
400
    const uint8_t *buf = avpkt->data;
219
400
    int buf_size       = avpkt->size;
220
400
    AVFrame *const p = data;
221
    int mb_x, mb_y, ret;
222
223
400
    if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)
224
        return AVERROR_INVALIDDATA;
225
226
400
    if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
227
        return ret;
228
400
    p->pict_type = AV_PICTURE_TYPE_I;
229
400
    p->key_frame = 1;
230
231
400
    if (avctx->codec_id == AV_CODEC_ID_ASV1) {
232
200
        av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size,
233
                              buf_size);
234
200
        if (!a->bitstream_buffer)
235
            return AVERROR(ENOMEM);
236
237
200
        a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,
238
                           (const uint32_t *) buf, buf_size / 4);
239
200
        ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);
240
    } else {
241
200
        ret = init_get_bits8_le(&a->gb, buf, buf_size);
242
    }
243
400
    if (ret < 0)
244
        return ret;
245
246
6000
    for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
247
124800
        for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
248
119200
            if ((ret = decode_mb(a, a->block)) < 0)
249
                return ret;
250
251
119200
            idct_put(a, p, mb_x, mb_y);
252
        }
253
    }
254
255
400
    if (a->mb_width2 != a->mb_width) {
256
100
        mb_x = a->mb_width2;
257
300
        for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
258
200
            if ((ret = decode_mb(a, a->block)) < 0)
259
                return ret;
260
261
200
            idct_put(a, p, mb_x, mb_y);
262
        }
263
    }
264
265
400
    if (a->mb_height2 != a->mb_height) {
266
100
        mb_y = a->mb_height2;
267
400
        for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
268
300
            if ((ret = decode_mb(a, a->block)) < 0)
269
                return ret;
270
271
300
            idct_put(a, p, mb_x, mb_y);
272
        }
273
    }
274
275
400
    *got_frame = 1;
276
277
400
    emms_c();
278
279
400
    return (get_bits_count(&a->gb) + 31) / 32 * 4;
280
}
281
282
18
static av_cold int decode_init(AVCodecContext *avctx)
283
{
284
    static AVOnce init_static_once = AV_ONCE_INIT;
285
18
    ASV1Context *const a = avctx->priv_data;
286
18
    const int scale      = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
287
    int i;
288
289
18
    if (avctx->extradata_size < 1) {
290
        av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");
291
    }
292
293
18
    ff_asv_common_init(avctx);
294
18
    ff_blockdsp_init(&a->bdsp, avctx);
295
18
    ff_idctdsp_init(&a->idsp, avctx);
296
18
    ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);
297
18
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
298
299

18
    if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {
300
        av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
301
        if (avctx->codec_id == AV_CODEC_ID_ASV1)
302
            a->inv_qscale = 6;
303
        else
304
            a->inv_qscale = 10;
305
    }
306
307
1170
    for (i = 0; i < 64; i++) {
308
1152
        int index = ff_asv_scantab[i];
309
310
1152
        a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /
311
1152
                             a->inv_qscale;
312
    }
313
314
18
    ff_thread_once(&init_static_once, init_vlcs);
315
316
18
    return 0;
317
}
318
319
9
static av_cold int decode_end(AVCodecContext *avctx)
320
{
321
9
    ASV1Context *const a = avctx->priv_data;
322
323
9
    av_freep(&a->bitstream_buffer);
324
9
    a->bitstream_buffer_size = 0;
325
326
9
    return 0;
327
}
328
329
#if CONFIG_ASV1_DECODER
330
AVCodec ff_asv1_decoder = {
331
    .name           = "asv1",
332
    .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
333
    .type           = AVMEDIA_TYPE_VIDEO,
334
    .id             = AV_CODEC_ID_ASV1,
335
    .priv_data_size = sizeof(ASV1Context),
336
    .init           = decode_init,
337
    .close          = decode_end,
338
    .decode         = decode_frame,
339
    .capabilities   = AV_CODEC_CAP_DR1,
340
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
341
};
342
#endif
343
344
#if CONFIG_ASV2_DECODER
345
AVCodec ff_asv2_decoder = {
346
    .name           = "asv2",
347
    .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
348
    .type           = AVMEDIA_TYPE_VIDEO,
349
    .id             = AV_CODEC_ID_ASV2,
350
    .priv_data_size = sizeof(ASV1Context),
351
    .init           = decode_init,
352
    .decode         = decode_frame,
353
    .capabilities   = AV_CODEC_CAP_DR1,
354
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
355
};
356
#endif