GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/asvenc.c Lines: 193 205 94.1 %
Date: 2019-11-22 03:34:36 Branches: 108 120 90.0 %

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 "mathops.h"
36
#include "mpeg12data.h"
37
38
718813
static inline void asv2_put_bits(PutBitContext *pb, int n, int v)
39
{
40
718813
    put_bits(pb, n, ff_reverse[v << (8 - n)]);
41
718813
}
42
43
2972884
static inline void asv1_put_level(PutBitContext *pb, int level)
44
{
45
2972884
    unsigned int index = level + 3;
46
47
2972884
    if (index <= 6) {
48
2543172
        put_bits(pb, ff_asv_level_tab[index][1], ff_asv_level_tab[index][0]);
49
    } else {
50
429712
        put_bits(pb, ff_asv_level_tab[3][1], ff_asv_level_tab[3][0]);
51
429712
        put_sbits(pb, 8, level);
52
    }
53
2972884
}
54
55
3660409
static inline void asv2_put_level(ASV1Context *a, PutBitContext *pb, int level)
56
{
57
3660409
    unsigned int index = level + 31;
58
59
3660409
    if (index <= 62) {
60
3659796
        put_bits(pb, ff_asv2_level_tab[index][1], ff_asv2_level_tab[index][0]);
61
    } else {
62
613
        put_bits(pb, ff_asv2_level_tab[31][1], ff_asv2_level_tab[31][0]);
63

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

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