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 uni_speedhq_ac_vlc_len[64 * 64 * 2];
50
reverse(uint32_t num,int bits)51 static uint32_t reverse(uint32_t num, int bits)
52 {
53 return bitswap_32(num) >> (32 - bits);
54 }
55
reverse_code(const uint16_t * code,const uint8_t * bits,uint16_t * reversed_code,int num_entries)56 static void reverse_code(const uint16_t *code, const uint8_t *bits,
57 uint16_t *reversed_code, int num_entries)
58 {
59 for (int i = 0; i < num_entries; i++)
60 reversed_code[i] = reverse(code[i], bits[i]);
61 }
62
speedhq_init_static_data(void)63 static av_cold void speedhq_init_static_data(void)
64 {
65 /* Exactly the same as MPEG-2, except little-endian. */
66 reverse_code(ff_mpeg12_vlc_dc_lum_code,
67 ff_mpeg12_vlc_dc_lum_bits,
68 mpeg12_vlc_dc_lum_code_reversed,
69 12);
70 reverse_code(ff_mpeg12_vlc_dc_chroma_code,
71 ff_mpeg12_vlc_dc_chroma_bits,
72 mpeg12_vlc_dc_chroma_code_reversed,
73 12);
74
75 ff_rl_init(&ff_rl_speedhq, speedhq_static_rl_table_store);
76
77 /* build unified dc encoding tables */
78 for (int i = -255; i < 256; i++) {
79 int adiff, index;
80 int bits, code;
81 int diff = i;
82
83 adiff = FFABS(diff);
84 if (diff < 0)
85 diff--;
86 index = av_log2(2 * adiff);
87
88 bits = ff_mpeg12_vlc_dc_lum_bits[index] + index;
89 code = mpeg12_vlc_dc_lum_code_reversed[index] +
90 (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]);
91 speedhq_lum_dc_uni[i + 255] = bits + (code << 8);
92
93 bits = ff_mpeg12_vlc_dc_chroma_bits[index] + index;
94 code = mpeg12_vlc_dc_chroma_code_reversed[index] +
95 (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]);
96 speedhq_chr_dc_uni[i + 255] = bits + (code << 8);
97 }
98
99 ff_mpeg1_init_uni_ac_vlc(&ff_rl_speedhq, uni_speedhq_ac_vlc_len);
100 }
101
ff_speedhq_encode_init(MpegEncContext * s)102 av_cold int ff_speedhq_encode_init(MpegEncContext *s)
103 {
104 static AVOnce init_static_once = AV_ONCE_INIT;
105
106 av_assert0(s->slice_context_count == 1);
107
108 if (s->width > 65500 || s->height > 65500) {
109 av_log(s, AV_LOG_ERROR, "SpeedHQ does not support resolutions above 65500x65500\n");
110 return AVERROR(EINVAL);
111 }
112
113 s->min_qcoeff = -2048;
114 s->max_qcoeff = 2047;
115
116 ff_thread_once(&init_static_once, speedhq_init_static_data);
117
118 s->intra_ac_vlc_length =
119 s->intra_ac_vlc_last_length =
120 s->intra_chroma_ac_vlc_length =
121 s->intra_chroma_ac_vlc_last_length = uni_speedhq_ac_vlc_len;
122
123 switch (s->avctx->pix_fmt) {
124 case AV_PIX_FMT_YUV420P:
125 s->avctx->codec_tag = MKTAG('S','H','Q','0');
126 break;
127 case AV_PIX_FMT_YUV422P:
128 s->avctx->codec_tag = MKTAG('S','H','Q','2');
129 break;
130 case AV_PIX_FMT_YUV444P:
131 s->avctx->codec_tag = MKTAG('S','H','Q','4');
132 break;
133 default:
134 av_assert0(0);
135 }
136
137 return 0;
138 }
139
ff_speedhq_encode_picture_header(MpegEncContext * s)140 void ff_speedhq_encode_picture_header(MpegEncContext *s)
141 {
142 put_bits_le(&s->pb, 8, 100 - s->qscale * 2); /* FIXME why doubled */
143 put_bits_le(&s->pb, 24, 4); /* no second field */
144
145 /* length of first slice, will be filled out later */
146 s->slice_start = 4;
147 put_bits_le(&s->pb, 24, 0);
148 }
149
ff_speedhq_end_slice(MpegEncContext * s)150 void ff_speedhq_end_slice(MpegEncContext *s)
151 {
152 int slice_len;
153
154 flush_put_bits_le(&s->pb);
155 slice_len = s->pb.buf_ptr - (s->pb.buf + s->slice_start);
156 AV_WL24(s->pb.buf + s->slice_start, slice_len);
157
158 /* length of next slice, will be filled out later */
159 s->slice_start = s->pb.buf_ptr - s->pb.buf;
160 put_bits_le(&s->pb, 24, 0);
161 }
162
encode_dc(PutBitContext * pb,int diff,int component)163 static inline void encode_dc(PutBitContext *pb, int diff, int component)
164 {
165 unsigned int diff_u = diff + 255;
166 if (diff_u >= 511) {
167 int index;
168
169 if (diff < 0) {
170 index = av_log2_16bit(-2 * diff);
171 diff--;
172 } else {
173 index = av_log2_16bit(2 * diff);
174 }
175 if (component == 0)
176 put_bits_le(pb,
177 ff_mpeg12_vlc_dc_lum_bits[index] + index,
178 mpeg12_vlc_dc_lum_code_reversed[index] +
179 (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_lum_bits[index]));
180 else
181 put_bits_le(pb,
182 ff_mpeg12_vlc_dc_chroma_bits[index] + index,
183 mpeg12_vlc_dc_chroma_code_reversed[index] +
184 (av_mod_uintp2(diff, index) << ff_mpeg12_vlc_dc_chroma_bits[index]));
185 } else {
186 if (component == 0)
187 put_bits_le(pb,
188 speedhq_lum_dc_uni[diff + 255] & 0xFF,
189 speedhq_lum_dc_uni[diff + 255] >> 8);
190 else
191 put_bits_le(pb,
192 speedhq_chr_dc_uni[diff + 255] & 0xFF,
193 speedhq_chr_dc_uni[diff + 255] >> 8);
194 }
195 }
196
encode_block(MpegEncContext * s,int16_t * block,int n)197 static void encode_block(MpegEncContext *s, int16_t *block, int n)
198 {
199 int alevel, level, last_non_zero, dc, i, j, run, last_index, sign;
200 int code;
201 int component, val;
202
203 /* DC coef */
204 component = (n <= 3 ? 0 : (n&1) + 1);
205 dc = block[0]; /* overflow is impossible */
206 val = s->last_dc[component] - dc; /* opposite of most codecs */
207 encode_dc(&s->pb, val, component);
208 s->last_dc[component] = dc;
209
210 /* now quantify & encode AC coefs */
211 last_non_zero = 0;
212 last_index = s->block_last_index[n];
213
214 for (i = 1; i <= last_index; i++) {
215 j = s->intra_scantable.permutated[i];
216 level = block[j];
217
218 /* encode using VLC */
219 if (level != 0) {
220 run = i - last_non_zero - 1;
221
222 alevel = level;
223 MASK_ABS(sign, alevel);
224 sign &= 1;
225
226 if (alevel <= ff_rl_speedhq.max_level[0][run]) {
227 code = ff_rl_speedhq.index_run[0][run] + alevel - 1;
228 /* store the VLC & sign at once */
229 put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[code][1] + 1,
230 ff_rl_speedhq.table_vlc[code][0] + (sign << ff_rl_speedhq.table_vlc[code][1]));
231 } else {
232 /* escape seems to be pretty rare <5% so I do not optimize it */
233 put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[121][1], ff_rl_speedhq.table_vlc[121][0]);
234 /* escape: only clip in this case */
235 put_bits_le(&s->pb, 6, run);
236 put_bits_le(&s->pb, 12, level + 2048);
237 }
238 last_non_zero = i;
239 }
240 }
241 /* end of block */
242 put_bits_le(&s->pb, ff_rl_speedhq.table_vlc[122][1], ff_rl_speedhq.table_vlc[122][0]);
243 }
244
ff_speedhq_encode_mb(MpegEncContext * s,int16_t block[12][64])245 void ff_speedhq_encode_mb(MpegEncContext *s, int16_t block[12][64])
246 {
247 int i;
248 for(i=0;i<6;i++) {
249 encode_block(s, block[i], i);
250 }
251 if (s->chroma_format == CHROMA_444) {
252 encode_block(s, block[8], 8);
253 encode_block(s, block[9], 9);
254
255 encode_block(s, block[6], 6);
256 encode_block(s, block[7], 7);
257
258 encode_block(s, block[10], 10);
259 encode_block(s, block[11], 11);
260 } else if (s->chroma_format == CHROMA_422) {
261 encode_block(s, block[6], 6);
262 encode_block(s, block[7], 7);
263 }
264
265 s->i_tex_bits += get_bits_diff(s);
266 }
267
ff_speedhq_mb_rows_in_slice(int slice_num,int mb_height)268 static int ff_speedhq_mb_rows_in_slice(int slice_num, int mb_height)
269 {
270 return mb_height / 4 + (slice_num < (mb_height % 4));
271 }
272
ff_speedhq_mb_y_order_to_mb(int mb_y_order,int mb_height,int * first_in_slice)273 int ff_speedhq_mb_y_order_to_mb(int mb_y_order, int mb_height, int *first_in_slice)
274 {
275 int slice_num = 0;
276 while (mb_y_order >= ff_speedhq_mb_rows_in_slice(slice_num, mb_height)) {
277 mb_y_order -= ff_speedhq_mb_rows_in_slice(slice_num, mb_height);
278 slice_num++;
279 }
280 *first_in_slice = (mb_y_order == 0);
281 return mb_y_order * 4 + slice_num;
282 }
283
284 #if CONFIG_SPEEDHQ_ENCODER
285 static const AVClass speedhq_class = {
286 .class_name = "speedhq encoder",
287 .item_name = av_default_item_name,
288 .option = ff_mpv_generic_options,
289 .version = LIBAVUTIL_VERSION_INT,
290 };
291
292 AVCodec ff_speedhq_encoder = {
293 .name = "speedhq",
294 .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
295 .type = AVMEDIA_TYPE_VIDEO,
296 .id = AV_CODEC_ID_SPEEDHQ,
297 .priv_data_size = sizeof(MpegEncContext),
298 .init = ff_mpv_encode_init,
299 .encode2 = ff_mpv_encode_picture,
300 .close = ff_mpv_encode_end,
301 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
302 .pix_fmts = (const enum AVPixelFormat[]) {
303 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
304 AV_PIX_FMT_NONE
305 },
306 .priv_class = &speedhq_class,
307 };
308 #endif
309