FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 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},
92  {0x1b,16},
93  {0x01,6}, /* escape */
94  {0x06,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)
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 
518  INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
519  FF_ARRAY_ELEMS(run_code),
520  run_bits, 1, 1,
521  run_code, 2, 2,
522  run_symbols, 2, 2, 160);
523 
524  /* Initialize VLC for alpha level. */
525  entry = 0;
526 
527  for (sign = 0; sign <= 1; ++sign) {
528  /* 1s -> -1 or +1 (depending on sign bit). */
529  level_code[entry] = (sign << 1) | 1;
530  level_bits[entry] = 2;
531  level_symbols[entry] = sign ? -1 : 1;
532  ++entry;
533 
534  /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
535  for (i = 0; i < 4; ++i) {
536  level_code[entry] = (i << 3) | (sign << 2) | 2;
537  level_bits[entry] = 5;
538  level_symbols[entry] = sign ? -(i + 2) : (i + 2);
539  ++entry;
540  }
541  }
542 
543  /*
544  * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
545  * here that would better be encoded in other ways (e.g. 0 would be
546  * encoded by increasing run, and +/- 1 would be encoded with a
547  * shorter code), but it doesn't hurt to allow everything.
548  */
549  for (i = 0; i < 256; ++i) {
550  level_code[entry] = i << 2;
551  level_bits[entry] = 10;
552  level_symbols[entry] = i;
553  ++entry;
554  }
555 
556  av_assert0(entry == FF_ARRAY_ELEMS(level_code));
557 
558  INIT_LE_VLC_SPARSE_STATIC(&ff_dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
559  FF_ARRAY_ELEMS(level_code),
560  level_bits, 1, 1,
561  level_code, 2, 2,
562  level_symbols, 2, 2, 288);
563 }
564 
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  int i;
584 
585  /* Exactly the same as MPEG-2, except little-endian. */
588  ff_mpeg12_vlc_dc_lum_code_reversed,
589  12);
590  INIT_LE_VLC_STATIC(&ff_dc_lum_vlc_le, DC_VLC_BITS, 12,
592  ff_mpeg12_vlc_dc_lum_code_reversed, 2, 2, 512);
595  ff_mpeg12_vlc_dc_chroma_code_reversed,
596  12);
597  INIT_LE_VLC_STATIC(&ff_dc_chroma_vlc_le, DC_VLC_BITS, 12,
599  ff_mpeg12_vlc_dc_chroma_code_reversed, 2, 2, 514);
600 
601  /* Reverse the AC VLC, because INIT_VLC_LE wants it in that order. */
602  for (i = 0; i < FF_ARRAY_ELEMS(speedhq_vlc); ++i) {
603  speedhq_vlc[i][0] = reverse(speedhq_vlc[i][0], speedhq_vlc[i][1]);
604  }
605  ff_rl_init(&ff_rl_speedhq, ff_speedhq_static_rl_table_store);
606  INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
607 
609 }
610 
612 {
613  int ret;
614  static AVOnce init_once = AV_ONCE_INIT;
615  SHQContext * const s = avctx->priv_data;
616 
617  s->avctx = avctx;
618 
619  ret = ff_thread_once(&init_once, speedhq_static_init);
620  if (ret)
621  return AVERROR_UNKNOWN;
622 
623  ff_blockdsp_init(&s->bdsp, avctx);
624  ff_idctdsp_init(&s->idsp, avctx);
626 
627  switch (avctx->codec_tag) {
628  case MKTAG('S', 'H', 'Q', '0'):
629  s->subsampling = SHQ_SUBSAMPLING_420;
630  s->alpha_type = SHQ_NO_ALPHA;
631  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
632  break;
633  case MKTAG('S', 'H', 'Q', '1'):
634  s->subsampling = SHQ_SUBSAMPLING_420;
635  s->alpha_type = SHQ_RLE_ALPHA;
636  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
637  break;
638  case MKTAG('S', 'H', 'Q', '2'):
639  s->subsampling = SHQ_SUBSAMPLING_422;
640  s->alpha_type = SHQ_NO_ALPHA;
641  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
642  break;
643  case MKTAG('S', 'H', 'Q', '3'):
644  s->subsampling = SHQ_SUBSAMPLING_422;
645  s->alpha_type = SHQ_RLE_ALPHA;
646  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
647  break;
648  case MKTAG('S', 'H', 'Q', '4'):
649  s->subsampling = SHQ_SUBSAMPLING_444;
650  s->alpha_type = SHQ_NO_ALPHA;
651  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
652  break;
653  case MKTAG('S', 'H', 'Q', '5'):
654  s->subsampling = SHQ_SUBSAMPLING_444;
655  s->alpha_type = SHQ_RLE_ALPHA;
656  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
657  break;
658  case MKTAG('S', 'H', 'Q', '7'):
659  s->subsampling = SHQ_SUBSAMPLING_422;
660  s->alpha_type = SHQ_DCT_ALPHA;
661  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
662  break;
663  case MKTAG('S', 'H', 'Q', '9'):
664  s->subsampling = SHQ_SUBSAMPLING_444;
665  s->alpha_type = SHQ_DCT_ALPHA;
666  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
667  break;
668  default:
669  av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
670  avctx->codec_tag);
671  return AVERROR_INVALIDDATA;
672  }
673 
674  /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
675  avctx->colorspace = AVCOL_SPC_BT470BG;
677 
678  return 0;
679 }
680 
682  .name = "speedhq",
683  .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
684  .type = AVMEDIA_TYPE_VIDEO,
685  .id = AV_CODEC_ID_SPEEDHQ,
686  .priv_data_size = sizeof(SHQContext),
689  .capabilities = AV_CODEC_CAP_DR1,
690 };
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:232
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
#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:201
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
static uint16_t speedhq_vlc[123][2]
Definition: speedhq.c:61
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1675
float re
Definition: fft.c:82
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:67
#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:479
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:1401
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:1697
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:3351
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
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:97
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:565
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
uint8_t * data
Definition: avcodec.h:1400
bitstream reader API header.
#define AVOnce
Definition: thread.h:157
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2125
#define FFALIGN(x, a)
Definition: macros.h:48
#define MAX_LEVEL
Definition: rl.h:36
#define av_log(a,...)
static av_cold void compute_alpha_vlcs(void)
Definition: speedhq.c:478
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:172
int width
Definition: frame.h:259
#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:186
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:3358
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
#define CLOSE_READER(name, gb)
Definition: get_bits.h:131
#define GET_RL_VLC(level, run, name, gb, table, bits,max_depth, need_update)
Definition: get_bits.h:509
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:66
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:175
static void compute_quant_matrix(int *output, int qscale)
Definition: speedhq.c:409
int width
picture width / height.
Definition: avcodec.h:1660
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:181
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:554
#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:477
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:193
#define FF_ARRAY_ELEMS(a)
#define INIT_VLC_LE
Definition: vlc.h:54
enum SHQContext::@133 alpha_type
#define AV_ONCE_INIT
Definition: thread.h:158
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:456
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:173
AVCodec ff_speedhq_decoder
Definition: speedhq.c:681
main external API structure.
Definition: avcodec.h:1488
MPEG-1/2 tables.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1513
static const uint8_t speedhq_level[121]
Definition: speedhq.c:97
#define OPEN_READER(name, gb)
Definition: get_bits.h:120
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
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:611
void * buf
Definition: avisynth_c.h:690
BlockDSPContext bdsp
Definition: speedhq.c:50
int coded_height
Definition: avcodec.h:1675
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2111
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:143
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
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:194
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:62
common internal api header.
ScanTable intra_scantable
Definition: speedhq.c:52
#define TEX_VLC_BITS
Definition: dv.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
#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:2037
void * priv_data
Definition: avcodec.h:1515
enum SHQContext::@132 subsampling
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:160
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
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:570
int height
Definition: frame.h:259
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:521
static av_cold void speedhq_static_init(void)
Definition: speedhq.c:579
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1377
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
static RLTable ff_rl_speedhq
Definition: speedhq.c:135