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