3 * Copyright 2017 Steinar H. Gunderson
5 * This file is part of FFmpeg.
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.
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.
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
24 * NewTek SpeedHQ decoder.
27 #define BITSTREAM_READER_LE
29 #include "libavutil/attributes.h"
34 #include "libavutil/thread.h"
37 #include "mpeg12data.h"
38 #include "mpeg12vlc.h"
40 #define MAX_INDEX (64 - 1)
43 * 5 bits makes for very small tables, with no more than two lookups needed
44 * for the longest (10-bit) codes.
46 #define ALPHA_VLC_BITS 5
48 typedef struct SHQContext {
49 AVCodecContext *avctx;
52 ScanTable intra_scantable;
54 enum { SHQ_SUBSAMPLING_420, SHQ_SUBSAMPLING_422, SHQ_SUBSAMPLING_444 }
56 enum { SHQ_NO_ALPHA, SHQ_RLE_ALPHA, SHQ_DCT_ALPHA } alpha_type;
60 /* AC codes: Very similar but not identical to MPEG-2. */
61 static uint16_t speedhq_vlc[123][2] = {
62 {0x02, 2}, {0x06, 3}, {0x07, 4}, {0x1c, 5},
63 {0x1d, 5}, {0x05, 6}, {0x04, 6}, {0x7b, 7},
64 {0x7c, 7}, {0x23, 8}, {0x22, 8}, {0xfa, 8},
65 {0xfb, 8}, {0xfe, 8}, {0xff, 8}, {0x1f,14},
66 {0x1e,14}, {0x1d,14}, {0x1c,14}, {0x1b,14},
67 {0x1a,14}, {0x19,14}, {0x18,14}, {0x17,14},
68 {0x16,14}, {0x15,14}, {0x14,14}, {0x13,14},
69 {0x12,14}, {0x11,14}, {0x10,14}, {0x18,15},
70 {0x17,15}, {0x16,15}, {0x15,15}, {0x14,15},
71 {0x13,15}, {0x12,15}, {0x11,15}, {0x10,15},
72 {0x02, 3}, {0x06, 5}, {0x79, 7}, {0x27, 8},
73 {0x20, 8}, {0x16,13}, {0x15,13}, {0x1f,15},
74 {0x1e,15}, {0x1d,15}, {0x1c,15}, {0x1b,15},
75 {0x1a,15}, {0x19,15}, {0x13,16}, {0x12,16},
76 {0x11,16}, {0x10,16}, {0x18,13}, {0x17,13},
77 {0x05, 5}, {0x07, 7}, {0xfc, 8}, {0x0c,10},
78 {0x14,13}, {0x18,12}, {0x14,12}, {0x13,12},
79 {0x10,12}, {0x1a,13}, {0x19,13}, {0x07, 5},
80 {0x26, 8}, {0x1c,12}, {0x13,13}, {0x1b,12},
81 {0x06, 6}, {0xfd, 8}, {0x12,12}, {0x1d,12},
82 {0x07, 6}, {0x04, 9}, {0x12,13}, {0x06, 7},
83 {0x1e,12}, {0x14,16}, {0x04, 7}, {0x15,12},
84 {0x05, 7}, {0x11,12}, {0x78, 7}, {0x11,13},
85 {0x7a, 7}, {0x10,13}, {0x21, 8}, {0x1a,16},
86 {0x25, 8}, {0x19,16}, {0x24, 8}, {0x18,16},
87 {0x05, 9}, {0x17,16}, {0x07, 9}, {0x16,16},
88 {0x0d,10}, {0x15,16}, {0x1f,12}, {0x1a,12},
89 {0x19,12}, {0x17,12}, {0x16,12}, {0x1f,13},
90 {0x1e,13}, {0x1d,13}, {0x1c,13}, {0x1b,13},
91 {0x1f,16}, {0x1e,16}, {0x1d,16}, {0x1c,16},
93 {0x01,6}, /* escape */
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,
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,
135 static RLTable ff_rl_speedhq = {
138 (const uint16_t (*)[])speedhq_vlc,
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
155 static uint8_t ff_speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
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;
162 static inline int decode_dc_le(GetBitContext *gb, int component)
166 if (component == 0 || component == 3) {
167 code = get_vlc2(gb, ff_dc_lum_vlc_le.table, DC_VLC_BITS, 2);
169 code = get_vlc2(gb, ff_dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
172 av_log(NULL, AV_LOG_ERROR, "invalid dc code at\n");
178 diff = get_xbits_le(gb, code);
183 static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
188 memset(block, 0, sizeof(block));
196 UPDATE_CACHE_LE(re, gb);
197 GET_VLC(run, re, gb, ff_dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
202 return AVERROR_INVALIDDATA;
204 UPDATE_CACHE_LE(re, gb);
205 GET_VLC(level, re, gb, ff_dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
209 CLOSE_READER(re, gb);
212 for (y = 0; y < 8; y++) {
213 for (x = 0; x < 16; x++) {
214 last_alpha[x] -= block[y * 16 + x];
216 memcpy(dest, last_alpha, 16);
223 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
225 const int *quant_matrix = s->quant_matrix;
226 const uint8_t *scantable = s->intra_scantable.permutated;
227 LOCAL_ALIGNED_16(int16_t, block, [64]);
230 s->bdsp.clear_block(block);
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. */
236 /* Read AC coefficients. */
242 UPDATE_CACHE_LE(re, gb);
243 GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
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);
257 #if MIN_CACHE_BITS < 6 + 6 + 12
258 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
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);
267 return AVERROR_INVALIDDATA;
270 block[scantable[i]] = (level * quant_matrix[i]) >> 4;
272 CLOSE_READER(re, gb);
275 s->idsp.idct_put(dest, linesize, block);
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)
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;
288 if (s->alpha_type != SHQ_NO_ALPHA)
289 linesize_a = frame->linesize[3] * line_stride;
291 if (end < start || end - start < 3 || end > buf_size)
292 return AVERROR_INVALIDDATA;
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;
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;
303 if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
304 return AVERROR_INVALIDDATA;
307 for (slice_number = 0; slice_number < 4; slice_number++) {
309 uint32_t slice_begin, slice_end;
312 slice_begin = slice_offsets[slice_number];
313 slice_end = slice_offsets[slice_number + 1];
315 if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
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];
323 memset(last_alpha, 255, sizeof(last_alpha));
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);
330 dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
331 dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
333 if (s->alpha_type != SHQ_NO_ALPHA) {
334 dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
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)
341 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
343 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
345 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
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.
352 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
354 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
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)
361 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
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)
368 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
370 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
372 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
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)
387 if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
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)
394 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
396 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
398 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
409 static void compute_quant_matrix(int *output, int qscale)
412 for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
415 static int speedhq_decode_frame(AVCodecContext *avctx,
416 void *data, int *got_frame,
419 SHQContext * const s = avctx->priv_data;
420 const uint8_t *buf = avpkt->data;
421 int buf_size = avpkt->size;
422 AVFrame *frame = data;
424 uint32_t second_field_offset;
428 return AVERROR_INVALIDDATA;
431 if (quality >= 100) {
432 return AVERROR_INVALIDDATA;
435 compute_quant_matrix(s->quant_matrix, 100 - quality);
437 second_field_offset = AV_RL24(buf + 1);
438 if (second_field_offset >= buf_size - 3) {
439 return AVERROR_INVALIDDATA;
442 avctx->coded_width = FFALIGN(avctx->width, 16);
443 avctx->coded_height = FFALIGN(avctx->height, 16);
445 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
448 frame->key_frame = 1;
450 if (second_field_offset == 4) {
452 * Overlapping first and second fields is used to signal
453 * encoding only a single field (the second field then comes
454 * as a separate, later frame).
457 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
460 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
462 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
471 * Alpha VLC. Run and level are independently coded, and would be
472 * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
473 * bother with combining them into one table.
475 static av_cold void compute_alpha_vlcs(void)
477 uint16_t run_code[134], level_code[266];
478 uint8_t run_bits[134], level_bits[266];
479 int16_t run_symbols[134], level_symbols[266];
482 /* Initialize VLC for alpha run. */
488 run_symbols[entry] = 0;
491 /* 10xx -> xx plus 1. */
492 for (i = 0; i < 4; ++i) {
493 run_code[entry] = (i << 2) | 1;
495 run_symbols[entry] = i + 1;
499 /* 111xxxxxxx -> xxxxxxx. */
500 for (i = 0; i < 128; ++i) {
501 run_code[entry] = (i << 3) | 7;
502 run_bits[entry] = 10;
503 run_symbols[entry] = i;
510 run_symbols[entry] = -1;
513 av_assert0(entry == FF_ARRAY_ELEMS(run_code));
515 INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
516 FF_ARRAY_ELEMS(run_code),
519 run_symbols, 2, 2, 160);
521 /* Initialize VLC for alpha level. */
524 for (sign = 0; sign <= 1; ++sign) {
525 /* 1s -> -1 or +1 (depending on sign bit). */
526 level_code[entry] = (sign << 1) | 1;
527 level_bits[entry] = 2;
528 level_symbols[entry] = sign ? -1 : 1;
531 /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
532 for (i = 0; i < 4; ++i) {
533 level_code[entry] = (i << 3) | (sign << 2) | 2;
534 level_bits[entry] = 5;
535 level_symbols[entry] = sign ? -(i + 2) : (i + 2);
541 * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
542 * here that would better be encoded in other ways (e.g. 0 would be
543 * encoded by increasing run, and +/- 1 would be encoded with a
544 * shorter code), but it doesn't hurt to allow everything.
546 for (i = 0; i < 256; ++i) {
547 level_code[entry] = i << 2;
548 level_bits[entry] = 10;
549 level_symbols[entry] = i;
553 av_assert0(entry == FF_ARRAY_ELEMS(level_code));
555 INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
556 FF_ARRAY_ELEMS(level_code),
559 level_symbols, 2, 2, 288);
562 static uint32_t reverse(uint32_t num, int bits)
564 return bitswap_32(num) >> (32 - bits);
567 static void reverse_code(const uint16_t *code, const uint8_t *bits,
568 uint16_t *reversed_code, int num_entries)
571 for (i = 0; i < num_entries; i++) {
572 reversed_code[i] = reverse(code[i], bits[i]);
576 static av_cold void speedhq_static_init(void)
578 uint16_t ff_mpeg12_vlc_dc_lum_code_reversed[12];
579 uint16_t ff_mpeg12_vlc_dc_chroma_code_reversed[12];
582 /* Exactly the same as MPEG-2, except little-endian. */
583 reverse_code(ff_mpeg12_vlc_dc_lum_code,
584 ff_mpeg12_vlc_dc_lum_bits,
585 ff_mpeg12_vlc_dc_lum_code_reversed,
587 INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
588 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
589 ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
590 reverse_code(ff_mpeg12_vlc_dc_chroma_code,
591 ff_mpeg12_vlc_dc_chroma_bits,
592 ff_mpeg12_vlc_dc_chroma_code_reversed,
594 INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
595 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
596 ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
598 /* Reverse the AC VLC, because INIT_VLC_LE wants it in that order. */
599 for (i = 0; i < FF_ARRAY_ELEMS(speedhq_vlc); ++i) {
600 speedhq_vlc[i][0] = reverse(speedhq_vlc[i][0], speedhq_vlc[i][1]);
602 ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
603 INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
605 compute_alpha_vlcs();
608 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
611 static AVOnce init_once = AV_ONCE_INIT;
612 SHQContext * const s = avctx->priv_data;
616 ret = ff_thread_once(&init_once, speedhq_static_init);
618 return AVERROR_UNKNOWN;
620 ff_blockdsp_init(&s->bdsp, avctx);
621 ff_idctdsp_init(&s->idsp, avctx);
622 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
624 switch (avctx->codec_tag) {
625 case MKTAG('S', 'H', 'Q', '0'):
626 s->subsampling = SHQ_SUBSAMPLING_420;
627 s->alpha_type = SHQ_NO_ALPHA;
628 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
630 case MKTAG('S', 'H', 'Q', '1'):
631 s->subsampling = SHQ_SUBSAMPLING_420;
632 s->alpha_type = SHQ_RLE_ALPHA;
633 avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
635 case MKTAG('S', 'H', 'Q', '2'):
636 s->subsampling = SHQ_SUBSAMPLING_422;
637 s->alpha_type = SHQ_NO_ALPHA;
638 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
640 case MKTAG('S', 'H', 'Q', '3'):
641 s->subsampling = SHQ_SUBSAMPLING_422;
642 s->alpha_type = SHQ_RLE_ALPHA;
643 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
645 case MKTAG('S', 'H', 'Q', '4'):
646 s->subsampling = SHQ_SUBSAMPLING_444;
647 s->alpha_type = SHQ_NO_ALPHA;
648 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
650 case MKTAG('S', 'H', 'Q', '5'):
651 s->subsampling = SHQ_SUBSAMPLING_444;
652 s->alpha_type = SHQ_RLE_ALPHA;
653 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
655 case MKTAG('S', 'H', 'Q', '7'):
656 s->subsampling = SHQ_SUBSAMPLING_422;
657 s->alpha_type = SHQ_DCT_ALPHA;
658 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
660 case MKTAG('S', 'H', 'Q', '9'):
661 s->subsampling = SHQ_SUBSAMPLING_444;
662 s->alpha_type = SHQ_DCT_ALPHA;
663 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
666 av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
668 return AVERROR_INVALIDDATA;
671 /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
672 avctx->colorspace = AVCOL_SPC_BT470BG;
673 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
678 AVCodec ff_speedhq_decoder = {
680 .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
681 .type = AVMEDIA_TYPE_VIDEO,
682 .id = AV_CODEC_ID_SPEEDHQ,
683 .priv_data_size = sizeof(SHQContext),
684 .init = speedhq_decode_init,
685 .decode = speedhq_decode_frame,
686 .capabilities = AV_CODEC_CAP_DR1,