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 "config.h"
30 #include "libavutil/attributes.h"
31 #include "libavutil/mem_internal.h"
32 
33 #include "avcodec.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "libavutil/thread.h"
37 #include "mathops.h"
38 #include "mpeg12.h"
39 #include "mpeg12data.h"
40 #include "mpeg12vlc.h"
41 
42 #define MAX_INDEX (64 - 1)
43 
44 /*
45  * 5 bits makes for very small tables, with no more than two lookups needed
46  * for the longest (10-bit) codes.
47  */
48 #define ALPHA_VLC_BITS 5
49 
50 typedef struct SHQContext {
55  int quant_matrix[64];
59 } SHQContext;
60 
61 
62 /* AC codes: Very similar but not identical to MPEG-2. */
63 static const uint16_t speedhq_vlc[123][2] = {
64  {0x0001, 2}, {0x0003, 3}, {0x000E, 4}, {0x0007, 5},
65  {0x0017, 5}, {0x0028, 6}, {0x0008, 6}, {0x006F, 7},
66  {0x001F, 7}, {0x00C4, 8}, {0x0044, 8}, {0x005F, 8},
67  {0x00DF, 8}, {0x007F, 8}, {0x00FF, 8}, {0x3E00, 14},
68  {0x1E00, 14}, {0x2E00, 14}, {0x0E00, 14}, {0x3600, 14},
69  {0x1600, 14}, {0x2600, 14}, {0x0600, 14}, {0x3A00, 14},
70  {0x1A00, 14}, {0x2A00, 14}, {0x0A00, 14}, {0x3200, 14},
71  {0x1200, 14}, {0x2200, 14}, {0x0200, 14}, {0x0C00, 15},
72  {0x7400, 15}, {0x3400, 15}, {0x5400, 15}, {0x1400, 15},
73  {0x6400, 15}, {0x2400, 15}, {0x4400, 15}, {0x0400, 15},
74  {0x0002, 3}, {0x000C, 5}, {0x004F, 7}, {0x00E4, 8},
75  {0x0004, 8}, {0x0D00, 13}, {0x1500, 13}, {0x7C00, 15},
76  {0x3C00, 15}, {0x5C00, 15}, {0x1C00, 15}, {0x6C00, 15},
77  {0x2C00, 15}, {0x4C00, 15}, {0xC800, 16}, {0x4800, 16},
78  {0x8800, 16}, {0x0800, 16}, {0x0300, 13}, {0x1D00, 13},
79  {0x0014, 5}, {0x0070, 7}, {0x003F, 8}, {0x00C0, 10},
80  {0x0500, 13}, {0x0180, 12}, {0x0280, 12}, {0x0C80, 12},
81  {0x0080, 12}, {0x0B00, 13}, {0x1300, 13}, {0x001C, 5},
82  {0x0064, 8}, {0x0380, 12}, {0x1900, 13}, {0x0D80, 12},
83  {0x0018, 6}, {0x00BF, 8}, {0x0480, 12}, {0x0B80, 12},
84  {0x0038, 6}, {0x0040, 9}, {0x0900, 13}, {0x0030, 7},
85  {0x0780, 12}, {0x2800, 16}, {0x0010, 7}, {0x0A80, 12},
86  {0x0050, 7}, {0x0880, 12}, {0x000F, 7}, {0x1100, 13},
87  {0x002F, 7}, {0x0100, 13}, {0x0084, 8}, {0x5800, 16},
88  {0x00A4, 8}, {0x9800, 16}, {0x0024, 8}, {0x1800, 16},
89  {0x0140, 9}, {0xE800, 16}, {0x01C0, 9}, {0x6800, 16},
90  {0x02C0, 10}, {0xA800, 16}, {0x0F80, 12}, {0x0580, 12},
91  {0x0980, 12}, {0x0E80, 12}, {0x0680, 12}, {0x1F00, 13},
92  {0x0F00, 13}, {0x1700, 13}, {0x0700, 13}, {0x1B00, 13},
93  {0xF800, 16}, {0x7800, 16}, {0xB800, 16}, {0x3800, 16},
94  {0xD800, 16},
95  {0x0020, 6}, /* escape */
96  {0x0006, 4} /* EOB */
97 };
98 
99 static const uint8_t speedhq_level[121] = {
100  1, 2, 3, 4, 5, 6, 7, 8,
101  9, 10, 11, 12, 13, 14, 15, 16,
102  17, 18, 19, 20, 21, 22, 23, 24,
103  25, 26, 27, 28, 29, 30, 31, 32,
104  33, 34, 35, 36, 37, 38, 39, 40,
105  1, 2, 3, 4, 5, 6, 7, 8,
106  9, 10, 11, 12, 13, 14, 15, 16,
107  17, 18, 19, 20, 1, 2, 3, 4,
108  5, 6, 7, 8, 9, 10, 11, 1,
109  2, 3, 4, 5, 1, 2, 3, 4,
110  1, 2, 3, 1, 2, 3, 1, 2,
111  1, 2, 1, 2, 1, 2, 1, 2,
112  1, 2, 1, 2, 1, 2, 1, 2,
113  1, 2, 1, 1, 1, 1, 1, 1,
114  1, 1, 1, 1, 1, 1, 1, 1,
115  1,
116 };
117 
118 static const uint8_t speedhq_run[121] = {
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  0, 0, 0, 0, 0, 0, 0, 0,
123  0, 0, 0, 0, 0, 0, 0, 0,
124  1, 1, 1, 1, 1, 1, 1, 1,
125  1, 1, 1, 1, 1, 1, 1, 1,
126  1, 1, 1, 1, 2, 2, 2, 2,
127  2, 2, 2, 2, 2, 2, 2, 3,
128  3, 3, 3, 3, 4, 4, 4, 4,
129  5, 5, 5, 6, 6, 6, 7, 7,
130  8, 8, 9, 9, 10, 10, 11, 11,
131  12, 12, 13, 13, 14, 14, 15, 15,
132  16, 16, 17, 18, 19, 20, 21, 22,
133  23, 24, 25, 26, 27, 28, 29, 30,
134  31,
135 };
136 
138  121,
139  121,
140  speedhq_vlc,
141  speedhq_run,
143 };
144 
145 #if CONFIG_SPEEDHQ_DECODER
146 /* NOTE: The first element is always 16, unscaled. */
147 static const uint8_t unscaled_quant_matrix[64] = {
148  16, 16, 19, 22, 26, 27, 29, 34,
149  16, 16, 22, 24, 27, 29, 34, 37,
150  19, 22, 26, 27, 29, 34, 34, 38,
151  22, 22, 26, 27, 29, 34, 37, 40,
152  22, 26, 27, 29, 32, 35, 40, 48,
153  26, 27, 29, 32, 35, 40, 48, 58,
154  26, 27, 29, 34, 38, 46, 56, 69,
155  27, 29, 35, 38, 46, 56, 69, 83
156 };
157 
159 
160 static VLC dc_lum_vlc_le;
161 static VLC dc_chroma_vlc_le;
162 static VLC dc_alpha_run_vlc_le;
163 static VLC dc_alpha_level_vlc_le;
164 
165 static inline int decode_dc_le(GetBitContext *gb, int component)
166 {
167  int code, diff;
168 
169  if (component == 0 || component == 3) {
170  code = get_vlc2(gb, dc_lum_vlc_le.table, DC_VLC_BITS, 2);
171  } else {
172  code = get_vlc2(gb, dc_chroma_vlc_le.table, DC_VLC_BITS, 2);
173  }
174  if (!code) {
175  diff = 0;
176  } else {
177  diff = get_xbits_le(gb, code);
178  }
179  return diff;
180 }
181 
182 static inline int decode_alpha_block(const SHQContext *s, GetBitContext *gb, uint8_t last_alpha[16], uint8_t *dest, int linesize)
183 {
184  uint8_t block[128];
185  int i = 0, x, y;
186 
187  memset(block, 0, sizeof(block));
188 
189  {
190  OPEN_READER(re, gb);
191 
192  for ( ;; ) {
193  int run, level;
194 
195  UPDATE_CACHE_LE(re, gb);
196  GET_VLC(run, re, gb, dc_alpha_run_vlc_le.table, ALPHA_VLC_BITS, 2);
197 
198  if (run < 0) break;
199  i += run;
200  if (i >= 128)
201  return AVERROR_INVALIDDATA;
202 
203  UPDATE_CACHE_LE(re, gb);
204  GET_VLC(level, re, gb, dc_alpha_level_vlc_le.table, ALPHA_VLC_BITS, 2);
205  block[i++] = level;
206  }
207 
208  CLOSE_READER(re, gb);
209  }
210 
211  for (y = 0; y < 8; y++) {
212  for (x = 0; x < 16; x++) {
213  last_alpha[x] -= block[y * 16 + x];
214  }
215  memcpy(dest, last_alpha, 16);
216  dest += linesize;
217  }
218 
219  return 0;
220 }
221 
222 static inline int decode_dct_block(const SHQContext *s, GetBitContext *gb, int last_dc[4], int component, uint8_t *dest, int linesize)
223 {
224  const int *quant_matrix = s->quant_matrix;
225  const uint8_t *scantable = s->intra_scantable.permutated;
226  LOCAL_ALIGNED_32(int16_t, block, [64]);
227  int dc_offset;
228 
229  s->bdsp.clear_block(block);
230 
231  dc_offset = decode_dc_le(gb, component);
232  last_dc[component] -= dc_offset; /* Note: Opposite of most codecs. */
233  block[scantable[0]] = last_dc[component]; /* quant_matrix[0] is always 16. */
234 
235  /* Read AC coefficients. */
236  {
237  int i = 0;
238  OPEN_READER(re, gb);
239  for ( ;; ) {
240  int level, run;
241  UPDATE_CACHE_LE(re, gb);
242  GET_RL_VLC(level, run, re, gb, ff_rl_speedhq.rl_vlc[0],
243  TEX_VLC_BITS, 2, 0);
244  if (level == 127) {
245  break;
246  } else if (level) {
247  i += run;
248  if (i > MAX_INDEX)
249  return AVERROR_INVALIDDATA;
250  /* If next bit is 1, level = -level */
251  level = (level ^ SHOW_SBITS(re, gb, 1)) -
252  SHOW_SBITS(re, gb, 1);
253  LAST_SKIP_BITS(re, gb, 1);
254  } else {
255  /* Escape. */
256 #if MIN_CACHE_BITS < 6 + 6 + 12
257 #error MIN_CACHE_BITS is too small for the escape code, add UPDATE_CACHE
258 #endif
259  run = SHOW_UBITS(re, gb, 6) + 1;
260  SKIP_BITS(re, gb, 6);
261  level = SHOW_UBITS(re, gb, 12) - 2048;
262  LAST_SKIP_BITS(re, gb, 12);
263 
264  i += run;
265  if (i > MAX_INDEX)
266  return AVERROR_INVALIDDATA;
267  }
268 
269  block[scantable[i]] = (level * quant_matrix[i]) >> 4;
270  }
271  CLOSE_READER(re, gb);
272  }
273 
274  s->idsp.idct_put(dest, linesize, block);
275 
276  return 0;
277 }
278 
279 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)
280 {
281  int ret, slice_number, slice_offsets[5];
282  int linesize_y = frame->linesize[0] * line_stride;
283  int linesize_cb = frame->linesize[1] * line_stride;
284  int linesize_cr = frame->linesize[2] * line_stride;
285  int linesize_a;
286 
287  if (s->alpha_type != SHQ_NO_ALPHA)
288  linesize_a = frame->linesize[3] * line_stride;
289 
290  if (end < start || end - start < 3 || end > buf_size)
291  return AVERROR_INVALIDDATA;
292 
293  slice_offsets[0] = start;
294  slice_offsets[4] = end;
295  for (slice_number = 1; slice_number < 4; slice_number++) {
296  uint32_t last_offset, slice_len;
297 
298  last_offset = slice_offsets[slice_number - 1];
299  slice_len = AV_RL24(buf + last_offset);
300  slice_offsets[slice_number] = last_offset + slice_len;
301 
302  if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
303  return AVERROR_INVALIDDATA;
304  }
305 
306  for (slice_number = 0; slice_number < 4; slice_number++) {
307  GetBitContext gb;
308  uint32_t slice_begin, slice_end;
309  int x, y;
310 
311  slice_begin = slice_offsets[slice_number];
312  slice_end = slice_offsets[slice_number + 1];
313 
314  if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
315  return ret;
316 
317  for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
318  uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
319  int last_dc[4] = { 1024, 1024, 1024, 1024 };
320  uint8_t last_alpha[16];
321 
322  memset(last_alpha, 255, sizeof(last_alpha));
323 
324  dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
325  if (s->subsampling == SHQ_SUBSAMPLING_420) {
326  dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
327  dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
328  } else {
329  dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
330  dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
331  }
332  if (s->alpha_type != SHQ_NO_ALPHA) {
333  dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
334  }
335 
336  for (x = 0; x < frame->width; x += 16) {
337  /* Decode the four luma blocks. */
338  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
339  return ret;
340  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
341  return ret;
342  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
343  return ret;
344  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
345  return ret;
346 
347  /*
348  * Decode the first chroma block. For 4:2:0, this is the only one;
349  * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
350  */
351  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
352  return ret;
353  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
354  return ret;
355 
356  if (s->subsampling != SHQ_SUBSAMPLING_420) {
357  /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
358  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
359  return ret;
360  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
361  return ret;
362 
363  if (s->subsampling == SHQ_SUBSAMPLING_444) {
364  /* Top-right and bottom-right blocks. */
365  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
366  return ret;
367  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
368  return ret;
369  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
370  return ret;
371  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
372  return ret;
373 
374  dest_cb += 8;
375  dest_cr += 8;
376  }
377  }
378  dest_y += 16;
379  dest_cb += 8;
380  dest_cr += 8;
381 
382  if (s->alpha_type == SHQ_RLE_ALPHA) {
383  /* Alpha coded using 16x8 RLE blocks. */
384  if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
385  return ret;
386  if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
387  return ret;
388  dest_a += 16;
389  } else if (s->alpha_type == SHQ_DCT_ALPHA) {
390  /* Alpha encoded exactly like luma. */
391  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
392  return ret;
393  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
394  return ret;
395  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
396  return ret;
397  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
398  return ret;
399  dest_a += 16;
400  }
401  }
402  }
403  }
404 
405  return 0;
406 }
407 
408 static void compute_quant_matrix(int *output, int qscale)
409 {
410  int i;
411  for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
412 }
413 
414 static int speedhq_decode_frame(AVCodecContext *avctx,
415  void *data, int *got_frame,
416  AVPacket *avpkt)
417 {
418  SHQContext * const s = avctx->priv_data;
419  const uint8_t *buf = avpkt->data;
420  int buf_size = avpkt->size;
421  AVFrame *frame = data;
423  uint32_t second_field_offset;
424  int ret;
425 
426  if (buf_size < 4)
427  return AVERROR_INVALIDDATA;
428 
429  quality = buf[0];
430  if (quality >= 100) {
431  return AVERROR_INVALIDDATA;
432  }
433 
434  compute_quant_matrix(s->quant_matrix, 100 - quality);
435 
436  second_field_offset = AV_RL24(buf + 1);
437  if (second_field_offset >= buf_size - 3) {
438  return AVERROR_INVALIDDATA;
439  }
440 
441  avctx->coded_width = FFALIGN(avctx->width, 16);
442  avctx->coded_height = FFALIGN(avctx->height, 16);
443 
444  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
445  return ret;
446  }
447  frame->key_frame = 1;
448 
449  if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
450  /*
451  * Overlapping first and second fields is used to signal
452  * encoding only a single field. In this case, "height"
453  * is ambiguous; it could mean either the height of the
454  * frame as a whole, or of the field. The former would make
455  * more sense for compatibility with legacy decoders,
456  * but this matches the convention used in NDI, which is
457  * the primary user of this trick.
458  */
459  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
460  return ret;
461  } else {
462  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
463  return ret;
464  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
465  return ret;
466  }
467 
468  *got_frame = 1;
469  return buf_size;
470 }
471 
472 /*
473  * Alpha VLC. Run and level are independently coded, and would be
474  * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
475  * bother with combining them into one table.
476  */
477 static av_cold void compute_alpha_vlcs(void)
478 {
479  uint16_t run_code[134], level_code[266];
480  uint8_t run_bits[134], level_bits[266];
481  int16_t run_symbols[134], level_symbols[266];
482  int entry, i, sign;
483 
484  /* Initialize VLC for alpha run. */
485  entry = 0;
486 
487  /* 0 -> 0. */
488  run_code[entry] = 0;
489  run_bits[entry] = 1;
490  run_symbols[entry] = 0;
491  ++entry;
492 
493  /* 10xx -> xx plus 1. */
494  for (i = 0; i < 4; ++i) {
495  run_code[entry] = (i << 2) | 1;
496  run_bits[entry] = 4;
497  run_symbols[entry] = i + 1;
498  ++entry;
499  }
500 
501  /* 111xxxxxxx -> xxxxxxx. */
502  for (i = 0; i < 128; ++i) {
503  run_code[entry] = (i << 3) | 7;
504  run_bits[entry] = 10;
505  run_symbols[entry] = i;
506  ++entry;
507  }
508 
509  /* 110 -> EOB. */
510  run_code[entry] = 3;
511  run_bits[entry] = 3;
512  run_symbols[entry] = -1;
513  ++entry;
514 
515  av_assert0(entry == FF_ARRAY_ELEMS(run_code));
516 
517  INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
518  FF_ARRAY_ELEMS(run_code),
519  run_bits, 1, 1,
520  run_code, 2, 2,
521  run_symbols, 2, 2, 160);
522 
523  /* Initialize VLC for alpha level. */
524  entry = 0;
525 
526  for (sign = 0; sign <= 1; ++sign) {
527  /* 1s -> -1 or +1 (depending on sign bit). */
528  level_code[entry] = (sign << 1) | 1;
529  level_bits[entry] = 2;
530  level_symbols[entry] = sign ? -1 : 1;
531  ++entry;
532 
533  /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
534  for (i = 0; i < 4; ++i) {
535  level_code[entry] = (i << 3) | (sign << 2) | 2;
536  level_bits[entry] = 5;
537  level_symbols[entry] = sign ? -(i + 2) : (i + 2);
538  ++entry;
539  }
540  }
541 
542  /*
543  * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
544  * here that would better be encoded in other ways (e.g. 0 would be
545  * encoded by increasing run, and +/- 1 would be encoded with a
546  * shorter code), but it doesn't hurt to allow everything.
547  */
548  for (i = 0; i < 256; ++i) {
549  level_code[entry] = i << 2;
550  level_bits[entry] = 10;
551  level_symbols[entry] = i;
552  ++entry;
553  }
554 
555  av_assert0(entry == FF_ARRAY_ELEMS(level_code));
556 
557  INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
558  FF_ARRAY_ELEMS(level_code),
559  level_bits, 1, 1,
560  level_code, 2, 2,
561  level_symbols, 2, 2, 288);
562 }
563 
564 static av_cold void speedhq_static_init(void)
565 {
566  /* Exactly the same as MPEG-2, except for a little-endian reader. */
567  INIT_CUSTOM_VLC_STATIC(&dc_lum_vlc_le, DC_VLC_BITS, 12,
570  INIT_VLC_OUTPUT_LE, 512);
571  INIT_CUSTOM_VLC_STATIC(&dc_chroma_vlc_le, DC_VLC_BITS, 12,
574  INIT_VLC_OUTPUT_LE, 514);
575 
576  ff_rl_init(&ff_rl_speedhq, speedhq_static_rl_table_store);
577  INIT_2D_VLC_RL(ff_rl_speedhq, 674, INIT_VLC_LE);
578 
579  compute_alpha_vlcs();
580 }
581 
582 static av_cold int speedhq_decode_init(AVCodecContext *avctx)
583 {
584  int ret;
585  static AVOnce init_once = AV_ONCE_INIT;
586  SHQContext * const s = avctx->priv_data;
587 
588  s->avctx = avctx;
589 
590  ret = ff_thread_once(&init_once, speedhq_static_init);
591  if (ret)
592  return AVERROR_UNKNOWN;
593 
594  ff_blockdsp_init(&s->bdsp, avctx);
595  ff_idctdsp_init(&s->idsp, avctx);
597 
598  switch (avctx->codec_tag) {
599  case MKTAG('S', 'H', 'Q', '0'):
602  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
603  break;
604  case MKTAG('S', 'H', 'Q', '1'):
607  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
608  break;
609  case MKTAG('S', 'H', 'Q', '2'):
612  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
613  break;
614  case MKTAG('S', 'H', 'Q', '3'):
617  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
618  break;
619  case MKTAG('S', 'H', 'Q', '4'):
622  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
623  break;
624  case MKTAG('S', 'H', 'Q', '5'):
627  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
628  break;
629  case MKTAG('S', 'H', 'Q', '7'):
632  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
633  break;
634  case MKTAG('S', 'H', 'Q', '9'):
637  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
638  break;
639  default:
640  av_log(avctx, AV_LOG_ERROR, "Unknown NewTek SpeedHQ FOURCC provided (%08X)\n",
641  avctx->codec_tag);
642  return AVERROR_INVALIDDATA;
643  }
644 
645  /* This matches what NDI's RGB -> Y'CbCr 4:2:2 converter uses. */
646  avctx->colorspace = AVCOL_SPC_BT470BG;
648 
649  return 0;
650 }
651 
653  .name = "speedhq",
654  .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
655  .type = AVMEDIA_TYPE_VIDEO,
656  .id = AV_CODEC_ID_SPEEDHQ,
657  .priv_data_size = sizeof(SHQContext),
658  .init = speedhq_decode_init,
659  .decode = speedhq_decode_frame,
660  .capabilities = AV_CODEC_CAP_DR1,
661 };
662 #endif /* CONFIG_SPEEDHQ_DECODER */
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:344
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:719
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:42
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:518
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
Scantable.
Definition: idctdsp.h:31
MPEG-1/2 VLC.
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
int size
Definition: packet.h:364
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
IDCTDSPContext idsp
Definition: speedhq.c:53
int quant_matrix[64]
Definition: speedhq.c:55
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:112
#define FF_ARRAY_ELEMS(a)
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:205
AVCodec.
Definition: codec.h:190
RLTable.
Definition: rl.h:39
AVCodec ff_speedhq_decoder
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
Macro definitions for various function/variable attributes.
#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:101
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:30
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
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
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
uint8_t * data
Definition: packet.h:363
bitstream reader API header.
#define AVOnce
Definition: thread.h:172
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1173
#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:63
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
int width
Definition: frame.h:372
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
static const uint8_t speedhq_run[121]
Definition: speedhq.c:118
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:91
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
#define GET_RL_VLC(level, run, name, gb, table, bits,max_depth, need_update)
Definition: get_bits.h:738
Definition: vlc.h:26
enum SHQContext::@134 alpha_type
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
enum SHQContext::@133 subsampling
int width
picture width / height.
Definition: avcodec.h:704
static void decode_dct_block(RangeCoder *c, DCTBlockCoder *bc, uint8_t *dst, ptrdiff_t stride, int block_size, int *block, int mb_x, int mb_y)
Definition: mss3.c:565
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
static uint8_t speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: speedhqenc.c:39
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
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
#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:797
#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
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
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
#define INIT_VLC_LE
Definition: vlc.h:94
#define AV_ONCE_INIT
Definition: thread.h:173
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
main external API structure.
Definition: avcodec.h:531
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:556
static const uint8_t speedhq_level[121]
Definition: speedhq.c:99
#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:1884
BlockDSPContext bdsp
Definition: speedhq.c:52
int coded_height
Definition: avcodec.h:719
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
static void compute_quant_matrix(AGMContext *s, double qscale)
Definition: agm.c:534
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
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t level
Definition: svq3.c:206
#define INIT_CUSTOM_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, flags, static_size)
Definition: vlc.h:116
#define DC_VLC_BITS
Definition: intrax8.c:40
#define ALPHA_VLC_BITS
Definition: speedhq.c:48
#define MAX_RUN
Definition: rl.h:35
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
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:54
#define TEX_VLC_BITS
Definition: dv.h:99
#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:2033
void * priv_data
Definition: avcodec.h:558
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:175
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:392
AVCodecContext * avctx
Definition: speedhq.c:51
int height
Definition: frame.h:372
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:608
#define MKTAG(a, b, c, d)
Definition: common.h:478
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93
RLTable ff_rl_speedhq
Definition: speedhq.c:137