GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/asvenc.c Lines: 189 201 94.0 %
Date: 2021-04-20 15:25:36 Branches: 106 118 89.8 %

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 encoder.
24
 */
25
26
#include "libavutil/attributes.h"
27
#include "libavutil/mem.h"
28
29
#include "aandcttab.h"
30
#include "asv.h"
31
#include "avcodec.h"
32
#include "dct.h"
33
#include "fdctdsp.h"
34
#include "internal.h"
35
#include "mpeg12data.h"
36
37
2972884
static inline void asv1_put_level(PutBitContext *pb, int level)
38
{
39
2972884
    unsigned int index = level + 3;
40
41
2972884
    if (index <= 6) {
42
2543172
        put_bits(pb, ff_asv_level_tab[index][1], ff_asv_level_tab[index][0]);
43
    } else {
44
429712
        put_bits(pb, 3, 0); /* Escape code */
45
429712
        put_sbits(pb, 8, level);
46
    }
47
2972884
}
48
49
3660409
static inline void asv2_put_level(ASV1Context *a, PutBitContext *pb, int level)
50
{
51
3660409
    unsigned int index = level + 31;
52
53
3660409
    if (index <= 62) {
54
3659796
        put_bits_le(pb, ff_asv2_level_tab[index][1], ff_asv2_level_tab[index][0]);
55
    } else {
56
613
        put_bits_le(pb, 5, 0); /* Escape code */
57

613
        if (level < -128 || level > 127) {
58
            av_log(a->avctx, AV_LOG_WARNING, "Clipping level %d, increase qscale\n", level);
59
            level = av_clip_int8(level);
60
        }
61
613
        put_bits_le(pb, 8, level & 0xFF);
62
    }
63
3660409
}
64
65
359100
static inline void asv1_encode_block(ASV1Context *a, int16_t block[64])
66
{
67
    int i;
68
359100
    int nc_count = 0;
69
70
359100
    put_bits(&a->pb, 8, (block[0] + 32) >> 6);
71
359100
    block[0] = 0;
72
73
3950100
    for (i = 0; i < 10; i++) {
74
3591000
        const int index = ff_asv_scantab[4 * i];
75
3591000
        int ccp         = 0;
76
77
3591000
        if ((block[index + 0] = (block[index + 0] *
78
3591000
                                 a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
79
759471
            ccp |= 8;
80
3591000
        if ((block[index + 8] = (block[index + 8] *
81
3591000
                                 a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
82
828513
            ccp |= 4;
83
3591000
        if ((block[index + 1] = (block[index + 1] *
84
3591000
                                 a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
85
781213
            ccp |= 2;
86
3591000
        if ((block[index + 9] = (block[index + 9] *
87
3591000
                                 a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
88
603687
            ccp |= 1;
89
90
3591000
        if (ccp) {
91
1769652
            for (; nc_count; nc_count--)
92
405258
                put_bits(&a->pb, 2, 2); /* Skip */
93
94
1364394
            put_bits(&a->pb, ff_asv_ccp_tab[ccp][1], ff_asv_ccp_tab[ccp][0]);
95
96
1364394
            if (ccp & 8)
97
759471
                asv1_put_level(&a->pb, block[index + 0]);
98
1364394
            if (ccp & 4)
99
828513
                asv1_put_level(&a->pb, block[index + 8]);
100
1364394
            if (ccp & 2)
101
781213
                asv1_put_level(&a->pb, block[index + 1]);
102
1364394
            if (ccp & 1)
103
603687
                asv1_put_level(&a->pb, block[index + 9]);
104
        } else {
105
2226606
            nc_count++;
106
        }
107
    }
108
359100
    put_bits(&a->pb, 5, 0xF); /* End of block */
109
359100
}
110
111
359100
static inline void asv2_encode_block(ASV1Context *a, int16_t block[64])
112
{
113
    int i;
114
359100
    int count = 0;
115
116
14496453
    for (count = 63; count > 3; count--) {
117
14433466
        const int index = ff_asv_scantab[count];
118
14433466
        if ((block[index] * a->q_intra_matrix[index] + (1 << 15)) >> 16)
119
296113
            break;
120
    }
121
122
359100
    count >>= 2;
123
124
359100
    put_bits_le(&a->pb, 4, count);
125
359100
    put_bits_le(&a->pb, 8, (block[0] + 32) >> 6);
126
359100
    block[0] = 0;
127
128
2709128
    for (i = 0; i <= count; i++) {
129
2350028
        const int index = ff_asv_scantab[4 * i];
130
2350028
        int ccp         = 0;
131
132
2350028
        if ((block[index + 0] = (block[index + 0] *
133
2350028
                                 a->q_intra_matrix[index + 0] + (1 << 15)) >> 16))
134
968959
            ccp |= 8;
135
2350028
        if ((block[index + 8] = (block[index + 8] *
136
2350028
                                 a->q_intra_matrix[index + 8] + (1 << 15)) >> 16))
137
1014552
            ccp |= 4;
138
2350028
        if ((block[index + 1] = (block[index + 1] *
139
2350028
                                 a->q_intra_matrix[index + 1] + (1 << 15)) >> 16))
140
951514
            ccp |= 2;
141
2350028
        if ((block[index + 9] = (block[index + 9] *
142
2350028
                                 a->q_intra_matrix[index + 9] + (1 << 15)) >> 16))
143
725384
            ccp |= 1;
144
145
        av_assert2(i || ccp < 8);
146
2350028
        if (i)
147
1990928
            put_bits_le(&a->pb, ff_asv_ac_ccp_tab[ccp][1], ff_asv_ac_ccp_tab[ccp][0]);
148
        else
149
359100
            put_bits_le(&a->pb, ff_asv_dc_ccp_tab[ccp][1], ff_asv_dc_ccp_tab[ccp][0]);
150
151
2350028
        if (ccp) {
152
1697818
            if (ccp & 8)
153
968959
                asv2_put_level(a, &a->pb, block[index + 0]);
154
1697818
            if (ccp & 4)
155
1014552
                asv2_put_level(a, &a->pb, block[index + 8]);
156
1697818
            if (ccp & 2)
157
951514
                asv2_put_level(a, &a->pb, block[index + 1]);
158
1697818
            if (ccp & 1)
159
725384
                asv2_put_level(a, &a->pb, block[index + 9]);
160
        }
161
    }
162
359100
}
163
164
#define MAX_MB_SIZE (30 * 16 * 16 * 3 / 2 / 8)
165
166
119700
static inline int encode_mb(ASV1Context *a, int16_t block[6][64])
167
{
168
    int i;
169
170
119700
    av_assert0(put_bytes_left(&a->pb, 0) >= MAX_MB_SIZE);
171
172
119700
    if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {
173
418950
        for (i = 0; i < 6; i++)
174
359100
            asv1_encode_block(a, block[i]);
175
    } else {
176
418950
        for (i = 0; i < 6; i++) {
177
359100
            asv2_encode_block(a, block[i]);
178
        }
179
    }
180
119700
    return 0;
181
}
182
183
119700
static inline void dct_get(ASV1Context *a, const AVFrame *frame,
184
                           int mb_x, int mb_y)
185
{
186
119700
    int16_t (*block)[64] = a->block;
187
119700
    int linesize = frame->linesize[0];
188
    int i;
189
190
119700
    uint8_t *ptr_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;
191
119700
    uint8_t *ptr_cb = frame->data[1] + (mb_y *  8 * frame->linesize[1]) + mb_x *  8;
192
119700
    uint8_t *ptr_cr = frame->data[2] + (mb_y *  8 * frame->linesize[2]) + mb_x *  8;
193
194
119700
    a->pdsp.get_pixels(block[0], ptr_y,                    linesize);
195
119700
    a->pdsp.get_pixels(block[1], ptr_y + 8,                linesize);
196
119700
    a->pdsp.get_pixels(block[2], ptr_y + 8 * linesize,     linesize);
197
119700
    a->pdsp.get_pixels(block[3], ptr_y + 8 * linesize + 8, linesize);
198
598500
    for (i = 0; i < 4; i++)
199
478800
        a->fdsp.fdct(block[i]);
200
201
119700
    if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {
202
119700
        a->pdsp.get_pixels(block[4], ptr_cb, frame->linesize[1]);
203
119700
        a->pdsp.get_pixels(block[5], ptr_cr, frame->linesize[2]);
204
359100
        for (i = 4; i < 6; i++)
205
239400
            a->fdsp.fdct(block[i]);
206
    }
207
119700
}
208
209
500
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
210
                        const AVFrame *pict, int *got_packet)
211
{
212
500
    ASV1Context *const a = avctx->priv_data;
213
    int size, ret;
214
    int mb_x, mb_y;
215
216

500
    if (pict->width % 16 || pict->height % 16) {
217
100
        AVFrame *clone = av_frame_alloc();
218
        int i;
219
220
100
        if (!clone)
221
            return AVERROR(ENOMEM);
222
100
        clone->format = pict->format;
223
100
        clone->width  = FFALIGN(pict->width, 16);
224
100
        clone->height = FFALIGN(pict->height, 16);
225
100
        ret = av_frame_get_buffer(clone, 0);
226
100
        if (ret < 0) {
227
            av_frame_free(&clone);
228
            return ret;
229
        }
230
231
100
        ret = av_frame_copy(clone, pict);
232
100
        if (ret < 0) {
233
            av_frame_free(&clone);
234
            return ret;
235
        }
236
237
400
        for (i = 0; i<3; i++) {
238
            int x, y;
239
300
            int w  = AV_CEIL_RSHIFT(pict->width, !!i);
240
300
            int h  = AV_CEIL_RSHIFT(pict->height, !!i);
241
300
            int w2 = AV_CEIL_RSHIFT(clone->width, !!i);
242
300
            int h2 = AV_CEIL_RSHIFT(clone->height, !!i);
243
7100
            for (y=0; y<h; y++)
244
78200
                for (x=w; x<w2; x++)
245
71400
                    clone->data[i][x + y*clone->linesize[i]] =
246
71400
                        clone->data[i][w - 1 + y*clone->linesize[i]];
247
3100
            for (y=h; y<h2; y++)
248
103600
                for (x=0; x<w2; x++)
249
100800
                    clone->data[i][x + y*clone->linesize[i]] =
250
100800
                        clone->data[i][x + (h-1)*clone->linesize[i]];
251
        }
252
100
        ret = encode_frame(avctx, pkt, clone, got_packet);
253
254
100
        av_frame_free(&clone);
255
100
        return ret;
256
    }
257
258
400
    if ((ret = ff_alloc_packet2(avctx, pkt, a->mb_height * a->mb_width * MAX_MB_SIZE +
259
                                AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
260
        return ret;
261
262
400
    init_put_bits(&a->pb, pkt->data, pkt->size);
263
264
6000
    for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
265
124800
        for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {
266
119200
            dct_get(a, pict, mb_x, mb_y);
267
119200
            encode_mb(a, a->block);
268
        }
269
    }
270
271
400
    if (a->mb_width2 != a->mb_width) {
272
100
        mb_x = a->mb_width2;
273
300
        for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {
274
200
            dct_get(a, pict, mb_x, mb_y);
275
200
            encode_mb(a, a->block);
276
        }
277
    }
278
279
400
    if (a->mb_height2 != a->mb_height) {
280
100
        mb_y = a->mb_height2;
281
400
        for (mb_x = 0; mb_x < a->mb_width; mb_x++) {
282
300
            dct_get(a, pict, mb_x, mb_y);
283
300
            encode_mb(a, a->block);
284
        }
285
    }
286
400
    emms_c();
287
288
400
    if (avctx->codec_id == AV_CODEC_ID_ASV1)
289
200
        flush_put_bits(&a->pb);
290
    else
291
200
        flush_put_bits_le(&a->pb);
292
400
    AV_WN32(put_bits_ptr(&a->pb), 0);
293
400
    size = (put_bytes_output(&a->pb) + 3) / 4;
294
295
400
    if (avctx->codec_id == AV_CODEC_ID_ASV1) {
296
200
        a->bbdsp.bswap_buf((uint32_t *) pkt->data,
297
200
                           (uint32_t *) pkt->data, size);
298
    }
299
300
400
    pkt->size   = size * 4;
301
400
    pkt->flags |= AV_PKT_FLAG_KEY;
302
400
    *got_packet = 1;
303
304
400
    return 0;
305
}
306
307
8
static av_cold int encode_init(AVCodecContext *avctx)
308
{
309
8
    ASV1Context *const a = avctx->priv_data;
310
    int i;
311
8
    const int scale = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;
312
313
8
    ff_asv_common_init(avctx);
314
8
    ff_fdctdsp_init(&a->fdsp, avctx);
315
8
    ff_pixblockdsp_init(&a->pdsp, avctx);
316
317
8
    if (avctx->global_quality <= 0)
318
        avctx->global_quality = 4 * FF_QUALITY_SCALE;
319
320
8
    a->inv_qscale = (32 * scale * FF_QUALITY_SCALE +
321
8
                     avctx->global_quality / 2) / avctx->global_quality;
322
323
8
    avctx->extradata                   = av_mallocz(8);
324
8
    if (!avctx->extradata)
325
        return AVERROR(ENOMEM);
326
8
    avctx->extradata_size              = 8;
327
8
    ((uint32_t *) avctx->extradata)[0] = av_le2ne32(a->inv_qscale);
328
8
    ((uint32_t *) avctx->extradata)[1] = av_le2ne32(AV_RL32("ASUS"));
329
330
520
    for (i = 0; i < 64; i++) {
331
512
        if (a->fdsp.fdct == ff_fdct_ifast) {
332
512
            int q = 32LL * scale * ff_mpeg1_default_intra_matrix[i] * ff_aanscales[i];
333
512
            a->q_intra_matrix[i] = (((int64_t)a->inv_qscale << 30) + q / 2) / q;
334
        } else {
335
            int q = 32 * scale * ff_mpeg1_default_intra_matrix[i];
336
            a->q_intra_matrix[i] = ((a->inv_qscale << 16) + q / 2) / q;
337
        }
338
    }
339
340
8
    return 0;
341
}
342
343
#if CONFIG_ASV1_ENCODER
344
AVCodec ff_asv1_encoder = {
345
    .name           = "asv1",
346
    .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
347
    .type           = AVMEDIA_TYPE_VIDEO,
348
    .id             = AV_CODEC_ID_ASV1,
349
    .priv_data_size = sizeof(ASV1Context),
350
    .init           = encode_init,
351
    .encode2        = encode_frame,
352
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
353
                                                     AV_PIX_FMT_NONE },
354
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
355
};
356
#endif
357
358
#if CONFIG_ASV2_ENCODER
359
AVCodec ff_asv2_encoder = {
360
    .name           = "asv2",
361
    .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
362
    .type           = AVMEDIA_TYPE_VIDEO,
363
    .id             = AV_CODEC_ID_ASV2,
364
    .priv_data_size = sizeof(ASV1Context),
365
    .init           = encode_init,
366
    .encode2        = encode_frame,
367
    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
368
                                                     AV_PIX_FMT_NONE },
369
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
370
};
371
#endif