1 /*
2 * NewTek SpeedHQ codec
3 * Copyright 2017 Steinar H. Gunderson
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * NewTek SpeedHQ decoder.
25 */
26
27 #define BITSTREAM_READER_LE
28
29 #include "libavutil/attributes.h"
30
31 #include "avcodec.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 #include "libavutil/thread.h"
35 #include "mathops.h"
36 #include "mpeg12.h"
37 #include "mpeg12data.h"
38 #include "mpeg12vlc.h"
39
40 #define MAX_INDEX (64 - 1)
41
42 /*
43 * 5 bits makes for very small tables, with no more than two lookups needed
44 * for the longest (10-bit) codes.
45 */
46 #define ALPHA_VLC_BITS 5
47
48 typedef struct SHQContext {
49 AVCodecContext *avctx;
50 BlockDSPContext bdsp;
51 IDCTDSPContext idsp;
52 ScanTable intra_scantable;
53 int quant_matrix[64];
54 enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
55 subsampling;
56 enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
57 } SHQContext;
58
59
60 /* AC codes: Very similar but not identical to MPEG-2. */
61 static const uint16_t speedhq_vlc[123][2] = {
62 {0x0001, 2}, {0x0003, 3}, {0x000E, 4}, {0x0007, 5},
63 {0x0017, 5}, {0x0028, 6}, {0x0008, 6}, {0x006F, 7},
64 {0x001F, 7}, {0x00C4, 8}, {0x0044, 8}, {0x005F, 8},
65 {0x00DF, 8}, {0x007F, 8}, {0x00FF, 8}, {0x3E00, 14},
66 {0x1E00, 14}, {0x2E00, 14}, {0x0E00, 14}, {0x3600, 14},
67 {0x1600, 14}, {0x2600, 14}, {0x0600, 14}, {0x3A00, 14},
68 {0x1A00, 14}, {0x2A00, 14}, {0x0A00, 14}, {0x3200, 14},
69 {0x1200, 14}, {0x2200, 14}, {0x0200, 14}, {0x0C00, 15},
70 {0x7400, 15}, {0x3400, 15}, {0x5400, 15}, {0x1400, 15},
71 {0x6400, 15}, {0x2400, 15}, {0x4400, 15}, {0x0400, 15},
72 {0x0002, 3}, {0x000C, 5}, {0x004F, 7}, {0x00E4, 8},
73 {0x0004, 8}, {0x0D00, 13}, {0x1500, 13}, {0x7C00, 15},
74 {0x3C00, 15}, {0x5C00, 15}, {0x1C00, 15}, {0x6C00, 15},
75 {0x2C00, 15}, {0x4C00, 15}, {0xC800, 16}, {0x4800, 16},
76 {0x8800, 16}, {0x0800, 16}, {0x0300, 13}, {0x1D00, 13},
77 {0x0014, 5}, {0x0070, 7}, {0x003F, 8}, {0x00C0, 10},
78 {0x0500, 13}, {0x0180, 12}, {0x0280, 12}, {0x0C80, 12},
79 {0x0080, 12}, {0x0B00, 13}, {0x1300, 13}, {0x001C, 5},
80 {0x0064, 8}, {0x0380, 12}, {0x1900, 13}, {0x0D80, 12},
81 {0x0018, 6}, {0x00BF, 8}, {0x0480, 12}, {0x0B80, 12},
82 {0x0038, 6}, {0x0040, 9}, {0x0900, 13}, {0x0030, 7},
83 {0x0780, 12}, {0x2800, 16}, {0x0010, 7}, {0x0A80, 12},
84 {0x0050, 7}, {0x0880, 12}, {0x000F, 7}, {0x1100, 13},
85 {0x002F, 7}, {0x0100, 13}, {0x0084, 8}, {0x5800, 16},
86 {0x00A4, 8}, {0x9800, 16}, {0x0024, 8}, {0x1800, 16},
87 {0x0140, 9}, {0xE800, 16}, {0x01C0, 9}, {0x6800, 16},
88 {0x02C0, 10}, {0xA800, 16}, {0x0F80, 12}, {0x0580, 12},
89 {0x0980, 12}, {0x0E80, 12}, {0x0680, 12}, {0x1F00, 13},
90 {0x0F00, 13}, {0x1700, 13}, {0x0700, 13}, {0x1B00, 13},
91 {0xF800, 16}, {0x7800, 16}, {0xB800, 16}, {0x3800, 16},
92 {0xD800, 16},
93 {0x0020, 6}, /* escape */
94 {0x0006, 4} /* EOB */
95 };
96
97 static const uint8_t speedhq_level[121] = {
98 1, 2, 3, 4, 5, 6, 7, 8,
99 9, 10, 11, 12, 13, 14, 15, 16,
100 17, 18, 19, 20, 21, 22, 23, 24,
101 25, 26, 27, 28, 29, 30, 31, 32,
102 33, 34, 35, 36, 37, 38, 39, 40,
103 1, 2, 3, 4, 5, 6, 7, 8,
104 9, 10, 11, 12, 13, 14, 15, 16,
105 17, 18, 19, 20, 1, 2, 3, 4,
106 5, 6, 7, 8, 9, 10, 11, 1,
107 2, 3, 4, 5, 1, 2, 3, 4,
108 1, 2, 3, 1, 2, 3, 1, 2,
109 1, 2, 1, 2, 1, 2, 1, 2,
110 1, 2, 1, 2, 1, 2, 1, 2,
111 1, 2, 1, 1, 1, 1, 1, 1,
112 1, 1, 1, 1, 1, 1, 1, 1,
113 1,
114 };
115
116 static const uint8_t speedhq_run[121] = {
117 0, 0, 0, 0, 0, 0, 0, 0,
118 0, 0, 0, 0, 0, 0, 0, 0,
119 0, 0, 0, 0, 0, 0, 0, 0,
120 0, 0, 0, 0, 0, 0, 0, 0,
121 0, 0, 0, 0, 0, 0, 0, 0,
122 1, 1, 1, 1, 1, 1, 1, 1,
123 1, 1, 1, 1, 1, 1, 1, 1,
124 1, 1, 1, 1, 2, 2, 2, 2,
125 2, 2, 2, 2, 2, 2, 2, 3,
126 3, 3, 3, 3, 4, 4, 4, 4,
127 5, 5, 5, 6, 6, 6, 7, 7,
128 8, 8, 9, 9, 10, 10, 11, 11,
129 12, 12, 13, 13, 14, 14, 15, 15,
130 16, 16, 17, 18, 19, 20, 21, 22,
131 23, 24, 25, 26, 27, 28, 29, 30,
132 31,
133 };
134
135 static RLTable ff_rl_speedhq = {
136 121,
137 121,
138 (const uint16_t (*)[])speedhq_vlc,
139 speedhq_run,
140 speedhq_level,
141 };
142
143 /* NOTE: The first element is always 16, unscaled. */
144 static const uint8_t unscaled_quant_matrix[64] = {
145 16, 16, 19, 22, 26, 27, 29, 34,
146 16, 16, 22, 24, 27, 29, 34, 37,
147 19, 22, 26, 27, 29, 34, 34, 38,
148 22, 22, 26, 27, 29, 34, 37, 40,
149 22, 26, 27, 29, 32, 35, 40, 48,
150 26, 27, 29, 32, 35, 40, 48, 58,
151 26, 27, 29, 34, 38, 46, 56, 69,
152 27, 29, 35, 38, 46, 56, 69, 83
153 };
154
155 static uint8_t ff_speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
156
157 static VLC ff_dc_lum_vlc_le;
158 static VLC ff_dc_chroma_vlc_le;
159 static VLC ff_dc_alpha_run_vlc_le;
160 static VLC ff_dc_alpha_level_vlc_le;
161
decode_dc_le(GetBitContext * gb,int component)162 static inline int decode_dc_le(GetBitContext *gb, int component)
163 {
164 int code, diff;
165
166 if (component == 0 || component == 3) {
167 code = get_vlc2(gb, ff_dc_lum_vlc_le.table, DC_VLC_BITS, 2);
168 } else {
169 code = get_vlc2(gb, ff_dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
170 }
171 if (code < 0) {
172 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
173 return 0xffff;
174 }
175 if (!code) {
176 diff = 0;
177 } else {
178 diff = get_xbits_le(gb, code);
179 }
180 return diff;
181 }
182
decode_alpha_block(const SHQContext * s,GetBitContext * gb,uint8_t last_alpha[16],uint8_t * dest,int linesize)183 static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
184 {
185 uint8_t block[128];
186 int i = 0, x, y;
187
188 memset(block, 0, sizeof(block));
189
190 {
191 OPEN_READER(re, gb);
192
193 for ( ;; ) {
194 int run, level;
195
196 UPDATE_CACHE_LE(re, gb);
197 GET_VLC(run, re, gb, ff_dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
198
199 if (run < 0) break;
200 i += run;
201 if (i >= 128)
202 return AVERROR_INVALIDDATA;
203
204 UPDATE_CACHE_LE(re, gb);
205 GET_VLC(level, re, gb, ff_dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
206 block[i++] = level;
207 }
208
209 CLOSE_READER(re, gb);
210 }
211
212 for (y = 0; y < 8; y++) {
213 for (x = 0; x < 16; x++) {
214 last_alpha[x] -= block[y * 16 + x];
215 }
216 memcpy(dest, last_alpha, 16);
217 dest += linesize;
218 }
219
220 return 0;
221 }
222
decode_dct_block(const SHQContext * s,GetBitContext * gb,int last_dc[4],int component,uint8_t * dest,int linesize)223 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
224 {
225 const int *quant_matrix = s->quant_matrix;
226 const uint8_t *scantable = s->intra_scantable.permutated;
227 LOCAL_ALIGNED_32(int16_t, block, [64]);
228 int dc_offset;
229
230 s->bdsp.clear_block(block);
231
232 dc_offset = decode_dc_le(gb, component);
233 last_dc[component] -= dc_offset; /* Note: Opposite of most codecs. */
234 block[scantable[0]] = last_dc[component]; /* quant_matrix[0] is always 16. */
235
236 /* Read AC coefficients. */
237 {
238 int i = 0;
239 OPEN_READER(re, gb);
240 for ( ;; ) {
241 int level, run;
242 UPDATE_CACHE_LE(re, gb);
243 GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
244 TEX_VLC_BITS, 2, 0);
245 if (level == 127) {
246 break;
247 } else if (level) {
248 i += run;
249 if (i > MAX_INDEX)
250 return AVERROR_INVALIDDATA;
251 /* If next bit is 1, level = -level */
252 level = (level ^ SHOW_SBITS(re, gb, 1)) -
253 SHOW_SBITS(re, gb, 1);
254 LAST_SKIP_BITS(re, gb, 1);
255 } else {
256 /* Escape. */
257 #if MIN_CACHE_BITS < 6 + 6 + 12
258 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
259 #endif
260 run = SHOW_UBITS(re, gb, 6) + 1;
261 SKIP_BITS(re, gb, 6);
262 level = SHOW_UBITS(re, gb, 12) - 2048;
263 LAST_SKIP_BITS(re, gb, 12);
264
265 i += run;
266 if (i > MAX_INDEX)
267 return AVERROR_INVALIDDATA;
268 }
269
270 block[scantable[i]] = (level * quant_matrix[i]) >> 4;
271 }
272 CLOSE_READER(re, gb);
273 }
274
275 s->idsp.idct_put(dest, linesize, block);
276
277 return 0;
278 }
279
decode_speedhq_field(const SHQContext * s,const uint8_t * buf,int buf_size,AVFrame * frame,int field_number,int start,int end,int line_stride)280 static int decode_speedhq_field(const SHQContext *s, const uint8_t *buf, int buf_size, AVFrame *frame, int field_number, int start, int end, int line_stride)
281 {
282 int ret, slice_number, slice_offsets[5];
283 int linesize_y = frame->linesize[0] * line_stride;
284 int linesize_cb = frame->linesize[1] * line_stride;
285 int linesize_cr = frame->linesize[2] * line_stride;
286 int linesize_a;
287
288 if (s->alpha_type != SHQ_NO_ALPHA)
289 linesize_a = frame->linesize[3] * line_stride;
290
291 if (end < start || end - start < 3 || end > buf_size)
292 return AVERROR_INVALIDDATA;
293
294 slice_offsets[0] = start;
295 slice_offsets[4] = end;
296 for (slice_number = 1; slice_number < 4; slice_number++) {
297 uint32_t last_offset, slice_len;
298
299 last_offset = slice_offsets[slice_number - 1];
300 slice_len = AV_RL24(buf + last_offset);
301 slice_offsets[slice_number] = last_offset + slice_len;
302
303 if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
304 return AVERROR_INVALIDDATA;
305 }
306
307 for (slice_number = 0; slice_number < 4; slice_number++) {
308 GetBitContext gb;
309 uint32_t slice_begin, slice_end;
310 int x, y;
311
312 slice_begin = slice_offsets[slice_number];
313 slice_end = slice_offsets[slice_number + 1];
314
315 if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
316 return ret;
317
318 for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
319 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
320 int last_dc[4] = { 1024, 1024, 1024, 1024 };
321 uint8_t last_alpha[16];
322
323 memset(last_alpha, 255, sizeof(last_alpha));
324
325 dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
326 if (s->subsampling == SHQ_SUBSAMPLING_420) {
327 dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
328 dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
329 } else {
330 dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
331 dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
332 }
333 if (s->alpha_type != SHQ_NO_ALPHA) {
334 dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
335 }
336
337 for (x = 0; x < frame->width; x += 16) {
338 /* Decode the four luma blocks. */
339 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
340 return ret;
341 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
342 return ret;
343 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
344 return ret;
345 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
346 return ret;
347
348 /*
349 * Decode the first chroma block. For 4:2:0, this is the only one;
350 * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
351 */
352 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
353 return ret;
354 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
355 return ret;
356
357 if (s->subsampling != SHQ_SUBSAMPLING_420) {
358 /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
359 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
360 return ret;
361 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
362 return ret;
363
364 if (s->subsampling == SHQ_SUBSAMPLING_444) {
365 /* Top-right and bottom-right blocks. */
366 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
367 return ret;
368 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
369 return ret;
370 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
371 return ret;
372 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
373 return ret;
374
375 dest_cb += 8;
376 dest_cr += 8;
377 }
378 }
379 dest_y += 16;
380 dest_cb += 8;
381 dest_cr += 8;
382
383 if (s->alpha_type == SHQ_RLE_ALPHA) {
384 /* Alpha coded using 16x8 RLE blocks. */
385 if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
386 return ret;
387 if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
388 return ret;
389 dest_a += 16;
390 } else if (s->alpha_type == SHQ_DCT_ALPHA) {
391 /* Alpha encoded exactly like luma. */
392 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
393 return ret;
394 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
395 return ret;
396 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
397 return ret;
398 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
399 return ret;
400 dest_a += 16;
401 }
402 }
403 }
404 }
405
406 return 0;
407 }
408
compute_quant_matrix(int * output,int qscale)409 static void compute_quant_matrix(int *output, int qscale)
410 {
411 int i;
412 for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
413 }
414
speedhq_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)415 static int speedhq_decode_frame(AVCodecContext *avctx,
416 void *data, int *got_frame,
417 AVPacket *avpkt)
418 {
419 SHQContext * const s = avctx->priv_data;
420 const uint8_t *buf = avpkt->data;
421 int buf_size = avpkt->size;
422 AVFrame *frame = data;
423 uint8_t quality;
424 uint32_t second_field_offset;
425 int ret;
426
427 if (buf_size < 4)
428 return AVERROR_INVALIDDATA;
429
430 quality = buf[0];
431 if (quality >= 100) {
432 return AVERROR_INVALIDDATA;
433 }
434
435 compute_quant_matrix(s->quant_matrix, 100 - quality);
436
437 second_field_offset = AV_RL24(buf + 1);
438 if (second_field_offset >= buf_size - 3) {
439 return AVERROR_INVALIDDATA;
440 }
441
442 avctx->coded_width = FFALIGN(avctx->width, 16);
443 avctx->coded_height = FFALIGN(avctx->height, 16);
444
445 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
446 return ret;
447 }
448 frame->key_frame = 1;
449
450 if (second_field_offset == 4) {
451 /*
452 * Overlapping first and second fields is used to signal
453 * encoding only a single field. In this case, "height"
454 * is ambiguous; it could mean either the height of the
455 * frame as a whole, or of the field. The former would make
456 * more sense for compatibility with legacy decoders,
457 * but this matches the convention used in NDI, which is
458 * the primary user of this trick.
459 */
460 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
461 return ret;
462 } else {
463 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
464 return ret;
465 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
466 return ret;
467 }
468
469 *got_frame = 1;
470 return buf_size;
471 }
472
473 /*
474 * Alpha VLC. Run and level are independently coded, and would be
475 * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
476 * bother with combining them into one table.
477 */
compute_alpha_vlcs(void)478 static av_cold void compute_alpha_vlcs(void)
479 {
480 uint16_t run_code[134], level_code[266];
481 uint8_t run_bits[134], level_bits[266];
482 int16_t run_symbols[134], level_symbols[266];
483 int entry, i, sign;
484
485 /* Initialize VLC for alpha run. */
486 entry = 0;
487
488 /* 0 -> 0. */
489 run_code[entry] = 0;
490 run_bits[entry] = 1;
491 run_symbols[entry] = 0;
492 ++entry;
493
494 /* 10xx -> xx plus 1. */
495 for (i = 0; i < 4; ++i) {
496 run_code[entry] = (i << 2) | 1;
497 run_bits[entry] = 4;
498 run_symbols[entry] = i + 1;
499 ++entry;
500 }
501
502 /* 111xxxxxxx -> xxxxxxx. */
503 for (i = 0; i < 128; ++i) {
504 run_code[entry] = (i << 3) | 7;
505 run_bits[entry] = 10;
506 run_symbols[entry] = i;
507 ++entry;
508 }
509
510 /* 110 -> EOB. */
511 run_code[entry] = 3;
512 run_bits[entry] = 3;
513 run_symbols[entry] = -1;
514 ++entry;
515
516 av_assert0(entry == FF_ARRAY_ELEMS(run_code));
517
518 INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
519 FF_ARRAY_ELEMS(run_code),
520 run_bits, 1, 1,
521 run_code, 2, 2,
522 run_symbols, 2, 2, 160);
523
524 /* Initialize VLC for alpha level. */
525 entry = 0;
526
527 for (sign = 0; sign <= 1; ++sign) {
528 /* 1s -> -1 or +1 (depending on sign bit). */
529 level_code[entry] = (sign << 1) | 1;
530 level_bits[entry] = 2;
531 level_symbols[entry] = sign ? -1 : 1;
532 ++entry;
533
534 /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
535 for (i = 0; i < 4; ++i) {
536 level_code[entry] = (i << 3) | (sign << 2) | 2;
537 level_bits[entry] = 5;
538 level_symbols[entry] = sign ? -(i + 2) : (i + 2);
539 ++entry;
540 }
541 }
542
543 /*
544 * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
545 * here that would better be encoded in other ways (e.g. 0 would be
546 * encoded by increasing run, and +/- 1 would be encoded with a
547 * shorter code), but it doesn't hurt to allow everything.
548 */
549 for (i = 0; i < 256; ++i) {
550 level_code[entry] = i << 2;
551 level_bits[entry] = 10;
552 level_symbols[entry] = i;
553 ++entry;
554 }
555
556 av_assert0(entry == FF_ARRAY_ELEMS(level_code));
557
558 INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
559 FF_ARRAY_ELEMS(level_code),
560 level_bits, 1, 1,
561 level_code, 2, 2,
562 level_symbols, 2, 2, 288);
563 }
564
reverse(uint32_t num,int bits)565 static uint32_t reverse(uint32_t num, int bits)
566 {
567 return bitswap_32(num) >> (32 - bits);
568 }
569
reverse_code(const uint16_t * code,const uint8_t * bits,uint16_t * reversed_code,int num_entries)570 static void reverse_code(const uint16_t *code, const uint8_t *bits,
571 uint16_t *reversed_code, int num_entries)
572 {
573 int i;
574 for (i = 0; i < num_entries; i++) {
575 reversed_code[i] = reverse(code[i], bits[i]);
576 }
577 }
578
speedhq_static_init(void)579 static av_cold void speedhq_static_init(void)
580 {
581 uint16_t ff_mpeg12_vlc_dc_lum_code_reversed[12];
582 uint16_t ff_mpeg12_vlc_dc_chroma_code_reversed[12];
583
584 /* Exactly the same as MPEG-2, except little-endian. */
585 reverse_code(ff_mpeg12_vlc_dc_lum_code,
586 ff_mpeg12_vlc_dc_lum_bits,
587 ff_mpeg12_vlc_dc_lum_code_reversed,
588 12);
589 INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
590 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
591 ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
592 reverse_code(ff_mpeg12_vlc_dc_chroma_code,
593 ff_mpeg12_vlc_dc_chroma_bits,
594 ff_mpeg12_vlc_dc_chroma_code_reversed,
595 12);
596 INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
597 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
598 ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
599
600 ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
601 INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
602
603 compute_alpha_vlcs();
604 }
605
speedhq_decode_init(AVCodecContext * avctx)606 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
607 {
608 int ret;
609 static AVOnce init_once = AV_ONCE_INIT;
610 SHQContext * const s = avctx->priv_data;
611
612 s->avctx = avctx;
613
614 ret = ff_thread_once(&init_once, speedhq_static_init);
615 if (ret)
616 return AVERROR_UNKNOWN;
617
618 ff_blockdsp_init(&s->bdsp, avctx);
619 ff_idctdsp_init(&s->idsp, avctx);
620 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
621
622 switch (avctx->codec_tag) {
623 case MKTAG('S', 'H', 'Q', '0'):
624 s->subsampling = SHQ_SUBSAMPLING_420;
625 s->alpha_type = SHQ_NO_ALPHA;
626 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
627 break;
628 case MKTAG('S', 'H', 'Q', '1'):
629 s->subsampling = SHQ_SUBSAMPLING_420;
630 s->alpha_type = SHQ_RLE_ALPHA;
631 avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
632 break;
633 case MKTAG('S', 'H', 'Q', '2'):
634 s->subsampling = SHQ_SUBSAMPLING_422;
635 s->alpha_type = SHQ_NO_ALPHA;
636 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
637 break;
638 case MKTAG('S', 'H', 'Q', '3'):
639 s->subsampling = SHQ_SUBSAMPLING_422;
640 s->alpha_type = SHQ_RLE_ALPHA;
641 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
642 break;
643 case MKTAG('S', 'H', 'Q', '4'):
644 s->subsampling = SHQ_SUBSAMPLING_444;
645 s->alpha_type = SHQ_NO_ALPHA;
646 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
647 break;
648 case MKTAG('S', 'H', 'Q', '5'):
649 s->subsampling = SHQ_SUBSAMPLING_444;
650 s->alpha_type = SHQ_RLE_ALPHA;
651 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
652 break;
653 case MKTAG('S', 'H', 'Q', '7'):
654 s->subsampling = SHQ_SUBSAMPLING_422;
655 s->alpha_type = SHQ_DCT_ALPHA;
656 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
657 break;
658 case MKTAG('S', 'H', 'Q', '9'):
659 s->subsampling = SHQ_SUBSAMPLING_444;
660 s->alpha_type = SHQ_DCT_ALPHA;
661 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
662 break;
663 default:
664 av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
665 avctx->codec_tag);
666 return AVERROR_INVALIDDATA;
667 }
668
669 /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
670 avctx->colorspace = AVCOL_SPC_BT470BG;
671 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
672
673 return 0;
674 }
675
676 AVCodec ff_speedhq_decoder = {
677 .name = "speedhq",
678 .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
679 .type = AVMEDIA_TYPE_VIDEO,
680 .id = AV_CODEC_ID_SPEEDHQ,
681 .priv_data_size = sizeof(SHQContext),
682 .init = speedhq_decode_init,
683 .decode = speedhq_decode_frame,
684 .capabilities = AV_CODEC_CAP_DR1,
685 };
686