GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/speedhqenc.c Lines: 0 134 0.0 %
Date: 2021-01-22 05:18:52 Branches: 0 42 0.0 %

Line Branch Exec Source
1
/*
2
 * SpeedHQ encoder
3
 * Copyright (c) 2000, 2001 Fabrice Bellard
4
 * Copyright (c) 2003 Alex Beregszaszi
5
 * Copyright (c) 2003-2004 Michael Niedermayer
6
 * Copyright (c) 2020 FFmpeg
7
 *
8
 * This file is part of FFmpeg.
9
 *
10
 * FFmpeg is free software; you can redistribute it and/or
11
 * modify it under the terms of the GNU Lesser General Public
12
 * License as published by the Free Software Foundation; either
13
 * version 2.1 of the License, or (at your option) any later version.
14
 *
15
 * FFmpeg is distributed in the hope that it will be useful,
16
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
 * Lesser General Public License for more details.
19
 *
20
 * You should have received a copy of the GNU Lesser General Public
21
 * License along with FFmpeg; if not, write to the Free Software
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23
 */
24
25
/**
26
 * @file
27
 * SpeedHQ encoder.
28
 */
29
30
#include "libavutil/pixdesc.h"
31
#include "libavutil/thread.h"
32
33
#include "avcodec.h"
34
#include "mpeg12.h"
35
#include "mpegvideo.h"
36
#include "speedhqenc.h"
37
38
extern RLTable ff_rl_speedhq;
39
static uint8_t speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
40
41
static uint16_t mpeg12_vlc_dc_lum_code_reversed[12];
42
static uint16_t mpeg12_vlc_dc_chroma_code_reversed[12];
43
44
/* simple include everything table for dc, first byte is bits
45
 * number next 3 are code */
46
static uint32_t speedhq_lum_dc_uni[512];
47
static uint32_t speedhq_chr_dc_uni[512];
48
49
static uint8_t speedhq_index_run[2][64];
50
static int8_t  speedhq_max_level[2][64];
51
52
static uint8_t uni_speedhq_ac_vlc_len[64 * 64 * 2];
53
54
static uint32_t reverse(uint32_t num, int bits)
55
{
56
    return bitswap_32(num) >> (32 - bits);
57
}
58
59
static void reverse_code(const uint16_t *code, const uint8_t *bits,
60
                         uint16_t *reversed_code, int num_entries)
61
{
62
    for (int i = 0; i < num_entries; i++)
63
        reversed_code[i] = reverse(code[i], bits[i]);
64
}
65
66
static av_cold void speedhq_init_static_data(void)
67
{
68
    /* Exactly the same as MPEG-2, except little-endian. */
69
    reverse_code(ff_mpeg12_vlc_dc_lum_code,
70
                 ff_mpeg12_vlc_dc_lum_bits,
71
                 mpeg12_vlc_dc_lum_code_reversed,
72
                 12);
73
    reverse_code(ff_mpeg12_vlc_dc_chroma_code,
74
                 ff_mpeg12_vlc_dc_chroma_bits,
75
                 mpeg12_vlc_dc_chroma_code_reversed,
76
                 12);
77
78
    ff_rl_init(&ff_rl_speedhq, speedhq_static_rl_table_store);
79
80
    for (int i = 0; i < 64; i++) {
81
        speedhq_max_level[0][i] = ff_rl_speedhq.max_level[0][i];
82
        speedhq_index_run[0][i] = ff_rl_speedhq.index_run[0][i];
83
    }
84
85
    /* build unified dc encoding tables */
86
    for (int i = -255; i < 256; i++) {
87
        int adiff, index;
88
        int bits, code;
89
        int diff = i;
90
91
        adiff = FFABS(diff);
92
        if (diff < 0)
93
            diff--;
94
        index = av_log2(2 * adiff);
95
96
        bits = ff_mpeg12_vlc_dc_lum_bits[index] + index;
97
        code = mpeg12_vlc_dc_lum_code_reversed[index] +
98
                (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]);
99
        speedhq_lum_dc_uni[i + 255] = bits + (code << 8);
100
101
        bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index;
102
        code = mpeg12_vlc_dc_chroma_code_reversed[index] +
103
                (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]);
104
        speedhq_chr_dc_uni[i + 255] = bits + (code << 8);
105
    }
106
107
    ff_mpeg1_init_uni_ac_vlc(&ff_rl_speedhq, uni_speedhq_ac_vlc_len);
108
}
109
110
av_cold int ff_speedhq_encode_init(MpegEncContext *s)
111
{
112
    static AVOnce init_static_once = AV_ONCE_INIT;
113
114
    av_assert0(s->slice_context_count == 1);
115
116
    if (s->width > 65500 || s->height > 65500) {
117
        av_log(s, AV_LOG_ERROR, "SpeedHQ does not support resolutions above 65500x65500\n");
118
        return AVERROR(EINVAL);
119
    }
120
121
    s->min_qcoeff = -2048;
122
    s->max_qcoeff = 2047;
123
124
    ff_thread_once(&init_static_once, speedhq_init_static_data);
125
126
    s->intra_ac_vlc_length      =
127
    s->intra_ac_vlc_last_length =
128
    s->intra_chroma_ac_vlc_length      =
129
    s->intra_chroma_ac_vlc_last_length = uni_speedhq_ac_vlc_len;
130
131
    switch (s->avctx->pix_fmt) {
132
    case AV_PIX_FMT_YUV420P:
133
        s->avctx->codec_tag = MKTAG('S','H','Q','0');
134
        break;
135
    case AV_PIX_FMT_YUV422P:
136
        s->avctx->codec_tag = MKTAG('S','H','Q','2');
137
        break;
138
    case AV_PIX_FMT_YUV444P:
139
        s->avctx->codec_tag = MKTAG('S','H','Q','4');
140
        break;
141
    default:
142
        av_assert0(0);
143
    }
144
145
    return 0;
146
}
147
148
void ff_speedhq_encode_picture_header(MpegEncContext *s)
149
{
150
    put_bits_le(&s->pb, 8, 100 - s->qscale * 2);  /* FIXME why doubled */
151
    put_bits_le(&s->pb, 24, 4);  /* no second field */
152
153
    /* length of first slice, will be filled out later */
154
    s->slice_start = 4;
155
    put_bits_le(&s->pb, 24, 0);
156
}
157
158
void ff_speedhq_end_slice(MpegEncContext *s)
159
{
160
    int slice_len;
161
162
    flush_put_bits_le(&s->pb);
163
    slice_len = s->pb.buf_ptr - (s->pb.buf + s->slice_start);
164
    AV_WL24(s->pb.buf + s->slice_start, slice_len);
165
166
    /* length of next slice, will be filled out later */
167
    s->slice_start = s->pb.buf_ptr - s->pb.buf;
168
    put_bits_le(&s->pb, 24, 0);
169
}
170
171
static inline void encode_dc(PutBitContext *pb, int diff, int component)
172
{
173
    unsigned int diff_u = diff + 255;
174
    if (diff_u >= 511) {
175
        int index;
176
177
        if (diff < 0) {
178
            index = av_log2_16bit(-2 * diff);
179
            diff--;
180
        } else {
181
            index = av_log2_16bit(2 * diff);
182
        }
183
        if (component == 0)
184
            put_bits_le(pb,
185
                        ff_mpeg12_vlc_dc_lum_bits[index] + index,
186
                        mpeg12_vlc_dc_lum_code_reversed[index] +
187
                        (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]));
188
        else
189
            put_bits_le(pb,
190
                        ff_mpeg12_vlc_dc_chroma_bits[index] + index,
191
                        mpeg12_vlc_dc_chroma_code_reversed[index] +
192
                        (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]));
193
    } else {
194
        if (component == 0)
195
            put_bits_le(pb,
196
                        speedhq_lum_dc_uni[diff + 255] & 0xFF,
197
                        speedhq_lum_dc_uni[diff + 255] >> 8);
198
        else
199
            put_bits_le(pb,
200
                        speedhq_chr_dc_uni[diff + 255] & 0xFF,
201
                        speedhq_chr_dc_uni[diff + 255] >> 8);
202
    }
203
}
204
205
static void encode_block(MpegEncContext *s, int16_t *block, int n)
206
{
207
    int alevel, level, last_non_zero, dc, i, j, run, last_index, sign;
208
    int code;
209
    int component, val;
210
211
    /* DC coef */
212
    component = (n <= 3 ? 0 : (n&1) + 1);
213
    dc = block[0]; /* overflow is impossible */
214
    val = s->last_dc[component] - dc;  /* opposite of most codecs */
215
    encode_dc(&s->pb, val, component);
216
    s->last_dc[component] = dc;
217
218
    /* now quantify & encode AC coefs */
219
    last_non_zero = 0;
220
    last_index = s->block_last_index[n];
221
222
    for (i = 1; i <= last_index; i++) {
223
        j     = s->intra_scantable.permutated[i];
224
        level = block[j];
225
226
        /* encode using VLC */
227
        if (level != 0) {
228
            run = i - last_non_zero - 1;
229
230
            alevel = level;
231
            MASK_ABS(sign, alevel);
232
            sign &= 1;
233
234
            if (alevel <= speedhq_max_level[0][run]) {
235
                code = speedhq_index_run[0][run] + alevel - 1;
236
                /* store the VLC & sign at once */
237
                put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[code][1] + 1,
238
                            ff_rl_speedhq.table_vlc[code][0] + (sign << ff_rl_speedhq.table_vlc[code][1]));
239
            } else {
240
                /* escape seems to be pretty rare <5% so I do not optimize it */
241
                put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[121][1], ff_rl_speedhq.table_vlc[121][0]);
242
                /* escape: only clip in this case */
243
                put_bits_le(&s->pb, 6, run);
244
                put_bits_le(&s->pb, 12, level + 2048);
245
            }
246
            last_non_zero = i;
247
        }
248
    }
249
    /* end of block */
250
    put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[122][1], ff_rl_speedhq.table_vlc[122][0]);
251
}
252
253
void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
254
{
255
    int i;
256
    for(i=0;i<6;i++) {
257
        encode_block(s, block[i], i);
258
    }
259
    if (s->chroma_format == CHROMA_444) {
260
        encode_block(s, block[8], 8);
261
        encode_block(s, block[9], 9);
262
263
        encode_block(s, block[6], 6);
264
        encode_block(s, block[7], 7);
265
266
        encode_block(s, block[10], 10);
267
        encode_block(s, block[11], 11);
268
    } else if (s->chroma_format == CHROMA_422) {
269
        encode_block(s, block[6], 6);
270
        encode_block(s, block[7], 7);
271
    }
272
273
    s->i_tex_bits += get_bits_diff(s);
274
}
275
276
static int ff_speedhq_mb_rows_in_slice(int slice_num, int mb_height)
277
{
278
    return mb_height / 4 + (slice_num < (mb_height % 4));
279
}
280
281
int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
282
{
283
    int slice_num = 0;
284
    while (mb_y_order >= ff_speedhq_mb_rows_in_slice(slice_num, mb_height)) {
285
         mb_y_order -= ff_speedhq_mb_rows_in_slice(slice_num, mb_height);
286
         slice_num++;
287
    }
288
    *first_in_slice = (mb_y_order == 0);
289
    return mb_y_order * 4 + slice_num;
290
}
291
292
#if CONFIG_SPEEDHQ_ENCODER
293
static const AVClass speedhq_class = {
294
    .class_name = "speedhq encoder",
295
    .item_name  = av_default_item_name,
296
    .option     = ff_mpv_generic_options,
297
    .version    = LIBAVUTIL_VERSION_INT,
298
};
299
300
AVCodec ff_speedhq_encoder = {
301
    .name           = "speedhq",
302
    .long_name      = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
303
    .type           = AVMEDIA_TYPE_VIDEO,
304
    .id             = AV_CODEC_ID_SPEEDHQ,
305
    .priv_data_size = sizeof(MpegEncContext),
306
    .init           = ff_mpv_encode_init,
307
    .encode2        = ff_mpv_encode_picture,
308
    .close          = ff_mpv_encode_end,
309
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
310
    .pix_fmts       = (const enum AVPixelFormat[]) {
311
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
312
        AV_PIX_FMT_NONE
313
    },
314
    .priv_class     = &speedhq_class,
315
};
316
#endif