FFmpeg
speedhq.c
Go to the documentation of this file.
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 {
53  int quant_matrix[64];
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 
136  121,
137  121,
138  (const uint16_t (*)[])speedhq_vlc,
139  speedhq_run,
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 
156 
161 
162 static inline int decode_dc_le(GetBitContext *gb, int component)
163 {
164  int code, diff;
165 
166  if (component == 0 || component == 3) {
168  } else {
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 
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);
198 
199  if (run < 0) break;
200  i += run;
201  if (i >= 128)
202  return AVERROR_INVALIDDATA;
203 
204  UPDATE_CACHE_LE(re, gb);
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 
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);
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 
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 
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 
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;
424  uint32_t second_field_offset;
425  int ret;
426 
427  if (buf_size < 4 || avctx->width < 8)
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  */
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 
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 
559  FF_ARRAY_ELEMS(level_code),
560  level_bits, 1, 1,
561  level_code, 2, 2,
562  level_symbols, 2, 2, 288);
563 }
564 
565 static uint32_t reverse(uint32_t num, int bits)
566 {
567  return bitswap_32(num) >> (32 - bits);
568 }
569 
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 
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. */
587  ff_mpeg12_vlc_dc_lum_code_reversed,
588  12);
591  ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
594  ff_mpeg12_vlc_dc_chroma_code_reversed,
595  12);
598  ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
599 
602 
604 }
605 
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;
672 
673  return 0;
674 }
675 
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),
684  .capabilities = AV_CODEC_CAP_DR1,
685 };
AVCodec
AVCodec.
Definition: codec.h:190
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
SHQContext::SHQ_NO_ALPHA
@ SHQ_NO_ALPHA
Definition: speedhq.c:56
decode_dct_block
static int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
Definition: speedhq.c:223
level
uint8_t level
Definition: svq3.c:210
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
SHQContext::intra_scantable
ScanTable intra_scantable
Definition: speedhq.c:52
bitswap_32
static av_always_inline uint32_t bitswap_32(uint32_t x)
Definition: mathops.h:243
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
decode_dc_le
static int decode_dc_le(GetBitContext *gb, int component)
Definition: speedhq.c:162
SHQContext::SHQ_DCT_ALPHA
@ SHQ_DCT_ALPHA
Definition: speedhq.c:56
thread.h
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
GET_VLC
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
Definition: get_bits.h:706
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
ff_dc_alpha_run_vlc_le
static VLC ff_dc_alpha_run_vlc_le
Definition: speedhq.c:159
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
data
const char data[16]
Definition: mxf.c:91
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
INIT_LE_VLC_SPARSE_STATIC
#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:66
unscaled_quant_matrix
static const uint8_t unscaled_quant_matrix[64]
Definition: speedhq.c:144
INIT_VLC_LE
#define INIT_VLC_LE
Definition: vlc.h:54
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
BlockDSPContext
Definition: blockdsp.h:35
reverse
static uint32_t reverse(uint32_t num, int bits)
Definition: speedhq.c:565
ff_mpeg12_vlc_dc_chroma_bits
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
speedhq_vlc
static const uint16_t speedhq_vlc[123][2]
Definition: speedhq.c:61
ff_mpeg12_vlc_dc_lum_bits
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
SHQContext::quant_matrix
int quant_matrix[64]
Definition: speedhq.c:53
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:515
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:61
mpeg12vlc.h
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:714
ff_dc_chroma_vlc_le
static VLC ff_dc_chroma_vlc_le
Definition: speedhq.c:158
SHQContext::SHQ_SUBSAMPLING_444
@ SHQ_SUBSAMPLING_444
Definition: speedhq.c:54
mpeg12.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
decode_alpha_block
static int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
Definition: speedhq.c:183
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2040
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
SHQContext::SHQ_RLE_ALPHA
@ SHQ_RLE_ALPHA
Definition: speedhq.c:56
bits
uint8_t bits
Definition: vp3data.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
SHQContext
Definition: speedhq.c:48
get_bits.h
speedhq_run
static const uint8_t speedhq_run[121]
Definition: speedhq.c:116
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
SHQContext::SHQ_SUBSAMPLING_420
@ SHQ_SUBSAMPLING_420
Definition: speedhq.c:54
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
SHQContext::alpha_type
enum SHQContext::@134 alpha_type
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:209
AV_CODEC_ID_SPEEDHQ
@ AV_CODEC_ID_SPEEDHQ
Definition: codec_id.h:269
mathops.h
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
compute_alpha_vlcs
static av_cold void compute_alpha_vlcs(void)
Definition: speedhq.c:478
speedhq_level
static const uint8_t speedhq_level[121]
Definition: speedhq.c:97
AVOnce
#define AVOnce
Definition: thread.h:172
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
run_bits
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
SHQContext::idsp
IDCTDSPContext idsp
Definition: speedhq.c:51
AV_RL24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:89
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
ff_dc_lum_vlc_le
static VLC ff_dc_lum_vlc_le
Definition: speedhq.c:157
speedhq_decode_init
static av_cold int speedhq_decode_init(AVCodecContext *avctx)
Definition: speedhq.c:606
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
attributes.h
SHQContext::bdsp
BlockDSPContext bdsp
Definition: speedhq.c:50
compute_quant_matrix
static void compute_quant_matrix(int *output, int qscale)
Definition: speedhq.c:409
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
ff_speedhq_decoder
AVCodec ff_speedhq_decoder
Definition: speedhq.c:676
ALPHA_VLC_BITS
#define ALPHA_VLC_BITS
Definition: speedhq.c:46
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dv.h:99
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
reverse_code
static void reverse_code(const uint16_t *code, const uint8_t *bits, uint16_t *reversed_code, int num_entries)
Definition: speedhq.c:570
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
SHQContext::SHQ_SUBSAMPLING_422
@ SHQ_SUBSAMPLING_422
Definition: speedhq.c:54
avcodec.h
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:738
ff_mpeg12_vlc_dc_chroma_code
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
get_xbits_le
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:344
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
IDCTDSPContext
Definition: idctdsp.h:53
speedhq_static_init
static av_cold void speedhq_static_init(void)
Definition: speedhq.c:579
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
mpeg12data.h
AVCodecContext
main external API structure.
Definition: avcodec.h:526
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
UPDATE_CACHE_LE
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:557
VLC
Definition: vlc.h:26
ff_rl_init
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
SHQContext::avctx
AVCodecContext * avctx
Definition: speedhq.c:49
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
ff_speedhq_static_rl_table_store
static uint8_t ff_speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: speedhq.c:155
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ScanTable
Scantable.
Definition: idctdsp.h:31
SHQContext::subsampling
enum SHQContext::@133 subsampling
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:551
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
INIT_2D_VLC_RL
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:32
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
decode_speedhq_field
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)
Definition: speedhq.c:280
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
ff_mpeg12_vlc_dc_lum_code
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
MAX_INDEX
#define MAX_INDEX
Definition: speedhq.c:40
DC_VLC_BITS
#define DC_VLC_BITS
Definition: intrax8.c:37
ff_rl_speedhq
static RLTable ff_rl_speedhq
Definition: speedhq.c:135
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
ff_dc_alpha_level_vlc_le
static VLC ff_dc_alpha_level_vlc_le
Definition: speedhq.c:160
INIT_LE_VLC_STATIC
#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:78
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
speedhq_decode_frame
static int speedhq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: speedhq.c:415
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
re
float re
Definition: fft.c:82