FFmpeg  4.1.11
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) {
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 
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 
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 
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;
423  uint8_t quality;
424  uint32_t second_field_offset;
425  int ret;
426 
427  if (buf_size < 4 || avctx->width < 8 || avctx->width % 8 != 0)
428  return AVERROR_INVALIDDATA;
429  if (buf_size < avctx->width*avctx->height / 64 / 4)
430  return AVERROR_INVALIDDATA;
431 
432  quality = buf[0];
433  if (quality >= 100) {
434  return AVERROR_INVALIDDATA;
435  }
436 
437  compute_quant_matrix(s->quant_matrix, 100 - quality);
438 
439  second_field_offset = AV_RL24(buf + 1);
440  if (second_field_offset >= buf_size - 3) {
441  return AVERROR_INVALIDDATA;
442  }
443 
444  avctx->coded_width = FFALIGN(avctx->width, 16);
445  avctx->coded_height = FFALIGN(avctx->height, 16);
446 
447  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
448  return ret;
449  }
450  frame->key_frame = 1;
451 
452  if (second_field_offset == 4) {
453  /*
454  * Overlapping first and second fields is used to signal
455  * encoding only a single field. In this case, "height"
456  * is ambiguous; it could mean either the height of the
457  * frame as a whole, or of the field. The former would make
458  * more sense for compatibility with legacy decoders,
459  * but this matches the convention used in NDI, which is
460  * the primary user of this trick.
461  */
462  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
463  return ret;
464  } else {
465  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
466  return ret;
467  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
468  return ret;
469  }
470 
471  *got_frame = 1;
472  return buf_size;
473 }
474 
475 /*
476  * Alpha VLC. Run and level are independently coded, and would be
477  * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
478  * bother with combining them into one table.
479  */
480 static av_cold void compute_alpha_vlcs(void)
481 {
482  uint16_t run_code[134], level_code[266];
483  uint8_t run_bits[134], level_bits[266];
484  int16_t run_symbols[134], level_symbols[266];
485  int entry, i, sign;
486 
487  /* Initialize VLC for alpha run. */
488  entry = 0;
489 
490  /* 0 -> 0. */
491  run_code[entry] = 0;
492  run_bits[entry] = 1;
493  run_symbols[entry] = 0;
494  ++entry;
495 
496  /* 10xx -> xx plus 1. */
497  for (i = 0; i < 4; ++i) {
498  run_code[entry] = (i << 2) | 1;
499  run_bits[entry] = 4;
500  run_symbols[entry] = i + 1;
501  ++entry;
502  }
503 
504  /* 111xxxxxxx -> xxxxxxx. */
505  for (i = 0; i < 128; ++i) {
506  run_code[entry] = (i << 3) | 7;
507  run_bits[entry] = 10;
508  run_symbols[entry] = i;
509  ++entry;
510  }
511 
512  /* 110 -> EOB. */
513  run_code[entry] = 3;
514  run_bits[entry] = 3;
515  run_symbols[entry] = -1;
516  ++entry;
517 
518  av_assert0(entry == FF_ARRAY_ELEMS(run_code));
519 
520  INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
521  FF_ARRAY_ELEMS(run_code),
522  run_bits, 1, 1,
523  run_code, 2, 2,
524  run_symbols, 2, 2, 160);
525 
526  /* Initialize VLC for alpha level. */
527  entry = 0;
528 
529  for (sign = 0; sign <= 1; ++sign) {
530  /* 1s -> -1 or +1 (depending on sign bit). */
531  level_code[entry] = (sign << 1) | 1;
532  level_bits[entry] = 2;
533  level_symbols[entry] = sign ? -1 : 1;
534  ++entry;
535 
536  /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
537  for (i = 0; i < 4; ++i) {
538  level_code[entry] = (i << 3) | (sign << 2) | 2;
539  level_bits[entry] = 5;
540  level_symbols[entry] = sign ? -(i + 2) : (i + 2);
541  ++entry;
542  }
543  }
544 
545  /*
546  * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
547  * here that would better be encoded in other ways (e.g. 0 would be
548  * encoded by increasing run, and +/- 1 would be encoded with a
549  * shorter code), but it doesn't hurt to allow everything.
550  */
551  for (i = 0; i < 256; ++i) {
552  level_code[entry] = i << 2;
553  level_bits[entry] = 10;
554  level_symbols[entry] = i;
555  ++entry;
556  }
557 
558  av_assert0(entry == FF_ARRAY_ELEMS(level_code));
559 
560  INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
561  FF_ARRAY_ELEMS(level_code),
562  level_bits, 1, 1,
563  level_code, 2, 2,
564  level_symbols, 2, 2, 288);
565 }
566 
567 static uint32_t reverse(uint32_t num, int bits)
568 {
569  return bitswap_32(num) >> (32 - bits);
570 }
571 
572 static void reverse_code(const uint16_t *code, const uint8_t *bits,
573  uint16_t *reversed_code, int num_entries)
574 {
575  int i;
576  for (i = 0; i < num_entries; i++) {
577  reversed_code[i] = reverse(code[i], bits[i]);
578  }
579 }
580 
581 static av_cold void speedhq_static_init(void)
582 {
583  uint16_t ff_mpeg12_vlc_dc_lum_code_reversed[12];
584  uint16_t ff_mpeg12_vlc_dc_chroma_code_reversed[12];
585 
586  /* Exactly the same as MPEG-2, except little-endian. */
589  ff_mpeg12_vlc_dc_lum_code_reversed,
590  12);
591  INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
593  ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
596  ff_mpeg12_vlc_dc_chroma_code_reversed,
597  12);
598  INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
600  ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
601 
603  INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
604 
606 }
607 
609 {
610  int ret;
611  static AVOnce init_once = AV_ONCE_INIT;
612  SHQContext * const s = avctx->priv_data;
613 
614  s->avctx = avctx;
615 
616  ret = ff_thread_once(&init_once, speedhq_static_init);
617  if (ret)
618  return AVERROR_UNKNOWN;
619 
620  ff_blockdsp_init(&s->bdsp, avctx);
621  ff_idctdsp_init(&s->idsp, avctx);
623 
624  switch (avctx->codec_tag) {
625  case MKTAG('S', 'H', 'Q', '0'):
628  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
629  break;
630  case MKTAG('S', 'H', 'Q', '1'):
633  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
634  break;
635  case MKTAG('S', 'H', 'Q', '2'):
638  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
639  break;
640  case MKTAG('S', 'H', 'Q', '3'):
643  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
644  break;
645  case MKTAG('S', 'H', 'Q', '4'):
648  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
649  break;
650  case MKTAG('S', 'H', 'Q', '5'):
653  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
654  break;
655  case MKTAG('S', 'H', 'Q', '7'):
658  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
659  break;
660  case MKTAG('S', 'H', 'Q', '9'):
663  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
664  break;
665  default:
666  av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
667  avctx->codec_tag);
668  return AVERROR_INVALIDDATA;
669  }
670 
671  /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
672  avctx->colorspace = AVCOL_SPC_BT470BG;
674 
675  return 0;
676 }
677 
679  .name = "speedhq",
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),
686  .capabilities = AV_CODEC_CAP_DR1,
687 };
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:346
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static VLC ff_dc_alpha_level_vlc_le
Definition: speedhq.c:160
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
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
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1721
float re
Definition: fft.c:82
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define MAX_INDEX
Definition: speedhq.c:40
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
static const uint8_t unscaled_quant_matrix[64]
Definition: speedhq.c:144
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:492
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
static int speedhq_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: speedhq.c:415
Scantable.
Definition: idctdsp.h:31
static av_always_inline uint32_t bitswap_32(uint32_t x)
Definition: mathops.h:243
MPEG-1/2 VLC.
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
int size
Definition: avcodec.h:1446
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
IDCTDSPContext idsp
Definition: speedhq.c:51
int quant_matrix[64]
Definition: speedhq.c:53
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1743
static VLC ff_dc_chroma_vlc_le
Definition: speedhq.c:158
#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:66
uint8_t permutated[64]
Definition: idctdsp.h:33
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
uint8_t run
Definition: svq3.c:206
AVCodec.
Definition: avcodec.h:3424
RLTable.
Definition: rl.h:39
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
Definition: speedhq.c:183
Macro definitions for various function/variable attributes.
static int decode_dc_le(GetBitContext *gb, int component)
Definition: speedhq.c:162
static int16_t block[64]
Definition: dct.c:115
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
enum SHQContext::@143 subsampling
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
uint8_t
#define av_cold
Definition: attributes.h:82
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:32
static VLC ff_dc_alpha_run_vlc_le
Definition: speedhq.c:159
static uint32_t reverse(uint32_t num, int bits)
Definition: speedhq.c:567
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
#define INIT_LE_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
Definition: vlc.h:78
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
uint8_t * data
Definition: avcodec.h:1445
bitstream reader API header.
#define AVOnce
Definition: thread.h:159
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2171
#define FFALIGN(x, a)
Definition: macros.h:48
#define MAX_LEVEL
Definition: rl.h:36
#define av_log(a,...)
static const uint16_t speedhq_vlc[123][2]
Definition: speedhq.c:61
static av_cold void compute_alpha_vlcs(void)
Definition: speedhq.c:480
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
int width
Definition: frame.h:284
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
static const uint8_t speedhq_run[121]
Definition: speedhq.c:116
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
Definition: vlc.h:26
static VLC ff_dc_lum_vlc_le
Definition: speedhq.c:157
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
static void compute_quant_matrix(int *output, int qscale)
Definition: speedhq.c:409
#define width
int width
picture width / height.
Definition: avcodec.h:1706
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:703
#define s(width, name)
Definition: cbs_vp9.c:257
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
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:762
#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:671
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
#define FF_ARRAY_ELEMS(a)
#define INIT_VLC_LE
Definition: vlc.h:54
#define AV_ONCE_INIT
Definition: thread.h:160
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:257
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:650
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AVCodec ff_speedhq_decoder
Definition: speedhq.c:678
main external API structure.
Definition: avcodec.h:1533
MPEG-1/2 tables.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1558
static const uint8_t speedhq_level[121]
Definition: speedhq.c:97
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1919
av_cold int ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:39
static av_cold int speedhq_decode_init(AVCodecContext *avctx)
Definition: speedhq.c:608
void * buf
Definition: avisynth_c.h:690
BlockDSPContext bdsp
Definition: speedhq.c:50
int coded_height
Definition: avcodec.h:1721
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2157
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
enum SHQContext::@144 alpha_type
#define AV_RL24
Definition: intreadwrite.h:78
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
uint8_t level
Definition: svq3.c:207
#define DC_VLC_BITS
Definition: intrax8.c:37
#define LOCAL_ALIGNED_32(t, v,...)
Definition: internal.h:137
#define ALPHA_VLC_BITS
Definition: speedhq.c:46
#define MAX_RUN
Definition: rl.h:35
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
static uint8_t ff_speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: speedhq.c:155
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
common internal api header.
ScanTable intra_scantable
Definition: speedhq.c:52
#define TEX_VLC_BITS
Definition: dv.h:96
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2026
void * priv_data
Definition: avcodec.h:1560
static av_always_inline int diff(const uint32_t a, const uint32_t b)
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:304
AVCodecContext * avctx
Definition: speedhq.c:49
static void reverse_code(const uint16_t *code, const uint8_t *bits, uint16_t *reversed_code, int num_entries)
Definition: speedhq.c:572
int height
Definition: frame.h:284
void INT64 start
Definition: avisynth_c.h:690
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:534
static av_cold void speedhq_static_init(void)
Definition: speedhq.c:581
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1422
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
static RLTable ff_rl_speedhq
Definition: speedhq.c:135