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 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},
93 {0x0020, 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 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 speedhq_static_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
157 static VLC dc_lum_vlc_le;
158 static VLC dc_chroma_vlc_le;
159 static VLC dc_alpha_run_vlc_le;
160 static VLC 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, dc_lum_vlc_le.table, DC_VLC_BITS, 2);
169 code = get_vlc2(gb, dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
174 diff = get_xbits_le(gb, code);
179 static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
184 memset(block, 0, sizeof(block));
192 UPDATE_CACHE_LE(re, gb);
193 GET_VLC(run, re, gb, dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
198 return AVERROR_INVALIDDATA;
200 UPDATE_CACHE_LE(re, gb);
201 GET_VLC(level, re, gb, dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
205 CLOSE_READER(re, gb);
208 for (y = 0; y < 8; y++) {
209 for (x = 0; x < 16; x++) {
210 last_alpha[x] -= block[y * 16 + x];
212 memcpy(dest, last_alpha, 16);
219 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
221 const int *quant_matrix = s->quant_matrix;
222 const uint8_t *scantable = s->intra_scantable.permutated;
223 LOCAL_ALIGNED_32(int16_t, block, [64]);
226 s->bdsp.clear_block(block);
228 dc_offset = decode_dc_le(gb, component);
229 last_dc[component] -= dc_offset; /* Note: Opposite of most codecs. */
230 block[scantable[0]] = last_dc[component]; /* quant_matrix[0] is always 16. */
232 /* Read AC coefficients. */
238 UPDATE_CACHE_LE(re, gb);
239 GET_RL_VLC(level, run, re, gb, rl_speedhq.rl_vlc[0],
246 return AVERROR_INVALIDDATA;
247 /* If next bit is 1, level = -level */
248 level = (level ^ SHOW_SBITS(re, gb, 1)) -
249 SHOW_SBITS(re, gb, 1);
250 LAST_SKIP_BITS(re, gb, 1);
253 #if MIN_CACHE_BITS < 6 + 6 + 12
254 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
256 run = SHOW_UBITS(re, gb, 6) + 1;
257 SKIP_BITS(re, gb, 6);
258 level = SHOW_UBITS(re, gb, 12) - 2048;
259 LAST_SKIP_BITS(re, gb, 12);
263 return AVERROR_INVALIDDATA;
266 block[scantable[i]] = (level * quant_matrix[i]) >> 4;
268 CLOSE_READER(re, gb);
271 s->idsp.idct_put(dest, linesize, block);
276 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)
278 int ret, slice_number, slice_offsets[5];
279 int linesize_y = frame->linesize[0] * line_stride;
280 int linesize_cb = frame->linesize[1] * line_stride;
281 int linesize_cr = frame->linesize[2] * line_stride;
284 if (s->alpha_type != SHQ_NO_ALPHA)
285 linesize_a = frame->linesize[3] * line_stride;
287 if (end < start || end - start < 3 || end > buf_size)
288 return AVERROR_INVALIDDATA;
290 slice_offsets[0] = start;
291 slice_offsets[4] = end;
292 for (slice_number = 1; slice_number < 4; slice_number++) {
293 uint32_t last_offset, slice_len;
295 last_offset = slice_offsets[slice_number - 1];
296 slice_len = AV_RL24(buf + last_offset);
297 slice_offsets[slice_number] = last_offset + slice_len;
299 if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
300 return AVERROR_INVALIDDATA;
303 for (slice_number = 0; slice_number < 4; slice_number++) {
305 uint32_t slice_begin, slice_end;
308 slice_begin = slice_offsets[slice_number];
309 slice_end = slice_offsets[slice_number + 1];
311 if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
314 for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
315 uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
316 int last_dc[4] = { 1024, 1024, 1024, 1024 };
317 uint8_t last_alpha[16];
319 memset(last_alpha, 255, sizeof(last_alpha));
321 dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
322 if (s->subsampling == SHQ_SUBSAMPLING_420) {
323 dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
324 dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
326 dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
327 dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
329 if (s->alpha_type != SHQ_NO_ALPHA) {
330 dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
333 for (x = 0; x < frame->width; x += 16) {
334 /* Decode the four luma blocks. */
335 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
337 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
339 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
341 if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
345 * Decode the first chroma block. For 4:2:0, this is the only one;
346 * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
348 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
350 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
353 if (s->subsampling != SHQ_SUBSAMPLING_420) {
354 /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
355 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
357 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
360 if (s->subsampling == SHQ_SUBSAMPLING_444) {
361 /* Top-right and bottom-right blocks. */
362 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
364 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
366 if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
368 if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
379 if (s->alpha_type == SHQ_RLE_ALPHA) {
380 /* Alpha coded using 16x8 RLE blocks. */
381 if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
383 if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
386 } else if (s->alpha_type == SHQ_DCT_ALPHA) {
387 /* Alpha encoded exactly like luma. */
388 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
390 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
392 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
394 if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
405 static void compute_quant_matrix(int *output, int qscale)
408 for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
411 static int speedhq_decode_frame(AVCodecContext *avctx,
412 void *data, int *got_frame,
415 SHQContext * const s = avctx->priv_data;
416 const uint8_t *buf = avpkt->data;
417 int buf_size = avpkt->size;
418 AVFrame *frame = data;
420 uint32_t second_field_offset;
424 return AVERROR_INVALIDDATA;
427 if (quality >= 100) {
428 return AVERROR_INVALIDDATA;
431 compute_quant_matrix(s->quant_matrix, 100 - quality);
433 second_field_offset = AV_RL24(buf + 1);
434 if (second_field_offset >= buf_size - 3) {
435 return AVERROR_INVALIDDATA;
438 avctx->coded_width = FFALIGN(avctx->width, 16);
439 avctx->coded_height = FFALIGN(avctx->height, 16);
441 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
444 frame->key_frame = 1;
446 if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
448 * Overlapping first and second fields is used to signal
449 * encoding only a single field. In this case, "height"
450 * is ambiguous; it could mean either the height of the
451 * frame as a whole, or of the field. The former would make
452 * more sense for compatibility with legacy decoders,
453 * but this matches the convention used in NDI, which is
454 * the primary user of this trick.
456 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
459 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
461 if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
470 * Alpha VLC. Run and level are independently coded, and would be
471 * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
472 * bother with combining them into one table.
474 static av_cold void compute_alpha_vlcs(void)
476 uint16_t run_code[134], level_code[266];
477 uint8_t run_bits[134], level_bits[266];
478 int16_t run_symbols[134], level_symbols[266];
481 /* Initialize VLC for alpha run. */
487 run_symbols[entry] = 0;
490 /* 10xx -> xx plus 1. */
491 for (i = 0; i < 4; ++i) {
492 run_code[entry] = (i << 2) | 1;
494 run_symbols[entry] = i + 1;
498 /* 111xxxxxxx -> xxxxxxx. */
499 for (i = 0; i < 128; ++i) {
500 run_code[entry] = (i << 3) | 7;
501 run_bits[entry] = 10;
502 run_symbols[entry] = i;
509 run_symbols[entry] = -1;
512 av_assert0(entry == FF_ARRAY_ELEMS(run_code));
514 INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
515 FF_ARRAY_ELEMS(run_code),
518 run_symbols, 2, 2, 160);
520 /* Initialize VLC for alpha level. */
523 for (sign = 0; sign <= 1; ++sign) {
524 /* 1s -> -1 or +1 (depending on sign bit). */
525 level_code[entry] = (sign << 1) | 1;
526 level_bits[entry] = 2;
527 level_symbols[entry] = sign ? -1 : 1;
530 /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
531 for (i = 0; i < 4; ++i) {
532 level_code[entry] = (i << 3) | (sign << 2) | 2;
533 level_bits[entry] = 5;
534 level_symbols[entry] = sign ? -(i + 2) : (i + 2);
540 * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
541 * here that would better be encoded in other ways (e.g. 0 would be
542 * encoded by increasing run, and +/- 1 would be encoded with a
543 * shorter code), but it doesn't hurt to allow everything.
545 for (i = 0; i < 256; ++i) {
546 level_code[entry] = i << 2;
547 level_bits[entry] = 10;
548 level_symbols[entry] = i;
552 av_assert0(entry == FF_ARRAY_ELEMS(level_code));
554 INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
555 FF_ARRAY_ELEMS(level_code),
558 level_symbols, 2, 2, 288);
561 static av_cold void speedhq_static_init(void)
563 /* Exactly the same as MPEG-2, except for a little-endian reader. */
564 INIT_CUSTOM_VLC_STATIC(&dc_lum_vlc_le, DC_VLC_BITS, 12,
565 ff_mpeg12_vlc_dc_lum_bits, 1, 1,
566 ff_mpeg12_vlc_dc_lum_code, 2, 2,
567 INIT_VLC_OUTPUT_LE, 512);
568 INIT_CUSTOM_VLC_STATIC(&dc_chroma_vlc_le, DC_VLC_BITS, 12,
569 ff_mpeg12_vlc_dc_chroma_bits, 1, 1,
570 ff_mpeg12_vlc_dc_chroma_code, 2, 2,
571 INIT_VLC_OUTPUT_LE, 514);
573 ff_rl_init(&rl_speedhq, speedhq_static_rl_table_store);
574 INIT_2D_VLC_RL(rl_speedhq, 674, INIT_VLC_LE);
576 compute_alpha_vlcs();
579 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
582 static AVOnce init_once = AV_ONCE_INIT;
583 SHQContext * const s = avctx->priv_data;
587 ret = ff_thread_once(&init_once, speedhq_static_init);
589 return AVERROR_UNKNOWN;
591 ff_blockdsp_init(&s->bdsp, avctx);
592 ff_idctdsp_init(&s->idsp, avctx);
593 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
595 switch (avctx->codec_tag) {
596 case MKTAG('S', 'H', 'Q', '0'):
597 s->subsampling = SHQ_SUBSAMPLING_420;
598 s->alpha_type = SHQ_NO_ALPHA;
599 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
601 case MKTAG('S', 'H', 'Q', '1'):
602 s->subsampling = SHQ_SUBSAMPLING_420;
603 s->alpha_type = SHQ_RLE_ALPHA;
604 avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
606 case MKTAG('S', 'H', 'Q', '2'):
607 s->subsampling = SHQ_SUBSAMPLING_422;
608 s->alpha_type = SHQ_NO_ALPHA;
609 avctx->pix_fmt = AV_PIX_FMT_YUV422P;
611 case MKTAG('S', 'H', 'Q', '3'):
612 s->subsampling = SHQ_SUBSAMPLING_422;
613 s->alpha_type = SHQ_RLE_ALPHA;
614 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
616 case MKTAG('S', 'H', 'Q', '4'):
617 s->subsampling = SHQ_SUBSAMPLING_444;
618 s->alpha_type = SHQ_NO_ALPHA;
619 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
621 case MKTAG('S', 'H', 'Q', '5'):
622 s->subsampling = SHQ_SUBSAMPLING_444;
623 s->alpha_type = SHQ_RLE_ALPHA;
624 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
626 case MKTAG('S', 'H', 'Q', '7'):
627 s->subsampling = SHQ_SUBSAMPLING_422;
628 s->alpha_type = SHQ_DCT_ALPHA;
629 avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
631 case MKTAG('S', 'H', 'Q', '9'):
632 s->subsampling = SHQ_SUBSAMPLING_444;
633 s->alpha_type = SHQ_DCT_ALPHA;
634 avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
637 av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
639 return AVERROR_INVALIDDATA;
642 /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
643 avctx->colorspace = AVCOL_SPC_BT470BG;
644 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
649 AVCodec ff_speedhq_decoder = {
651 .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
652 .type = AVMEDIA_TYPE_VIDEO,
653 .id = AV_CODEC_ID_SPEEDHQ,
654 .priv_data_size = sizeof(SHQContext),
655 .init = speedhq_decode_init,
656 .decode = speedhq_decode_frame,
657 .capabilities = AV_CODEC_CAP_DR1,