FFmpeg  4.4
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);
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_border(const SHQContext *s, GetBitContext *gb, AVFrame *frame, int field_number, int line_stride)
280 {
281  int linesize_y = frame->linesize[0] * line_stride;
282  int linesize_cb = frame->linesize[1] * line_stride;
283  int linesize_cr = frame->linesize[2] * line_stride;
284  int linesize_a;
285  int ret;
286 
287  if (s->alpha_type != SHQ_NO_ALPHA)
288  linesize_a = frame->linesize[3] * line_stride;
289 
290  for (int y = 0; y < frame->height; y += 16 * line_stride) {
291  int last_dc[4] = { 1024, 1024, 1024, 1024 };
292  uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
293  uint8_t last_alpha[16];
294  int x = frame->width - 8;
295 
296  dest_y = frame->data[0] + frame->linesize[0] * (y + field_number) + x;
297  if (s->subsampling == SHQ_SUBSAMPLING_420) {
298  dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number) + x / 2;
299  dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number) + x / 2;
300  } else if (s->subsampling == SHQ_SUBSAMPLING_422) {
301  dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number) + x / 2;
302  dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number) + x / 2;
303  }
304  if (s->alpha_type != SHQ_NO_ALPHA) {
305  memset(last_alpha, 255, sizeof(last_alpha));
306  dest_a = frame->data[3] + frame->linesize[3] * (y + field_number) + x;
307  }
308 
309  if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y, linesize_y)) < 0)
310  return ret;
311  if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
312  return ret;
313  if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
314  return ret;
315  if ((ret = decode_dct_block(s, gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
316  return ret;
317  if ((ret = decode_dct_block(s, gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
318  return ret;
319  if ((ret = decode_dct_block(s, gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
320  return ret;
321 
322  if (s->subsampling != SHQ_SUBSAMPLING_420) {
323  if ((ret = decode_dct_block(s, gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
324  return ret;
325  if ((ret = decode_dct_block(s, gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
326  return ret;
327  }
328 
329  if (s->alpha_type == SHQ_RLE_ALPHA) {
330  /* Alpha coded using 16x8 RLE blocks. */
331  if ((ret = decode_alpha_block(s, gb, last_alpha, dest_a, linesize_a)) < 0)
332  return ret;
333  if ((ret = decode_alpha_block(s, gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
334  return ret;
335  } else if (s->alpha_type == SHQ_DCT_ALPHA) {
336  /* Alpha encoded exactly like luma. */
337  if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a, linesize_a)) < 0)
338  return ret;
339  if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
340  return ret;
341  if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
342  return ret;
343  if ((ret = decode_dct_block(s, gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
344  return ret;
345  }
346  }
347 
348  return 0;
349 }
350 
351 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)
352 {
353  int ret, slice_number, slice_offsets[5];
354  int linesize_y = frame->linesize[0] * line_stride;
355  int linesize_cb = frame->linesize[1] * line_stride;
356  int linesize_cr = frame->linesize[2] * line_stride;
357  int linesize_a;
358  GetBitContext gb;
359 
360  if (s->alpha_type != SHQ_NO_ALPHA)
361  linesize_a = frame->linesize[3] * line_stride;
362 
363  if (end < start || end - start < 3 || end > buf_size)
364  return AVERROR_INVALIDDATA;
365 
366  slice_offsets[0] = start;
367  slice_offsets[4] = end;
368  for (slice_number = 1; slice_number < 4; slice_number++) {
369  uint32_t last_offset, slice_len;
370 
371  last_offset = slice_offsets[slice_number - 1];
372  slice_len = AV_RL24(buf + last_offset);
373  slice_offsets[slice_number] = last_offset + slice_len;
374 
375  if (slice_len < 3 || slice_offsets[slice_number] > end - 3)
376  return AVERROR_INVALIDDATA;
377  }
378 
379  for (slice_number = 0; slice_number < 4; slice_number++) {
380  uint32_t slice_begin, slice_end;
381  int x, y;
382 
383  slice_begin = slice_offsets[slice_number];
384  slice_end = slice_offsets[slice_number + 1];
385 
386  if ((ret = init_get_bits8(&gb, buf + slice_begin + 3, slice_end - slice_begin - 3)) < 0)
387  return ret;
388 
389  for (y = slice_number * 16 * line_stride; y < frame->height; y += line_stride * 64) {
390  uint8_t *dest_y, *dest_cb, *dest_cr, *dest_a;
391  int last_dc[4] = { 1024, 1024, 1024, 1024 };
392  uint8_t last_alpha[16];
393 
394  memset(last_alpha, 255, sizeof(last_alpha));
395 
396  dest_y = frame->data[0] + frame->linesize[0] * (y + field_number);
397  if (s->subsampling == SHQ_SUBSAMPLING_420) {
398  dest_cb = frame->data[1] + frame->linesize[1] * (y/2 + field_number);
399  dest_cr = frame->data[2] + frame->linesize[2] * (y/2 + field_number);
400  } else {
401  dest_cb = frame->data[1] + frame->linesize[1] * (y + field_number);
402  dest_cr = frame->data[2] + frame->linesize[2] * (y + field_number);
403  }
404  if (s->alpha_type != SHQ_NO_ALPHA) {
405  dest_a = frame->data[3] + frame->linesize[3] * (y + field_number);
406  }
407 
408  for (x = 0; x < frame->width - 8 * (s->subsampling != SHQ_SUBSAMPLING_444); x += 16) {
409  /* Decode the four luma blocks. */
410  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y, linesize_y)) < 0)
411  return ret;
412  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8, linesize_y)) < 0)
413  return ret;
414  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y, linesize_y)) < 0)
415  return ret;
416  if ((ret = decode_dct_block(s, &gb, last_dc, 0, dest_y + 8 * linesize_y + 8, linesize_y)) < 0)
417  return ret;
418 
419  /*
420  * Decode the first chroma block. For 4:2:0, this is the only one;
421  * for 4:2:2, it's the top block; for 4:4:4, it's the top-left block.
422  */
423  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb, linesize_cb)) < 0)
424  return ret;
425  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr, linesize_cr)) < 0)
426  return ret;
427 
428  if (s->subsampling != SHQ_SUBSAMPLING_420) {
429  /* For 4:2:2, this is the bottom block; for 4:4:4, it's the bottom-left block. */
430  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb, linesize_cb)) < 0)
431  return ret;
432  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr, linesize_cr)) < 0)
433  return ret;
434 
435  if (s->subsampling == SHQ_SUBSAMPLING_444) {
436  /* Top-right and bottom-right blocks. */
437  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8, linesize_cb)) < 0)
438  return ret;
439  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8, linesize_cr)) < 0)
440  return ret;
441  if ((ret = decode_dct_block(s, &gb, last_dc, 1, dest_cb + 8 * linesize_cb + 8, linesize_cb)) < 0)
442  return ret;
443  if ((ret = decode_dct_block(s, &gb, last_dc, 2, dest_cr + 8 * linesize_cr + 8, linesize_cr)) < 0)
444  return ret;
445 
446  dest_cb += 8;
447  dest_cr += 8;
448  }
449  }
450  dest_y += 16;
451  dest_cb += 8;
452  dest_cr += 8;
453 
454  if (s->alpha_type == SHQ_RLE_ALPHA) {
455  /* Alpha coded using 16x8 RLE blocks. */
456  if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a, linesize_a)) < 0)
457  return ret;
458  if ((ret = decode_alpha_block(s, &gb, last_alpha, dest_a + 8 * linesize_a, linesize_a)) < 0)
459  return ret;
460  dest_a += 16;
461  } else if (s->alpha_type == SHQ_DCT_ALPHA) {
462  /* Alpha encoded exactly like luma. */
463  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a, linesize_a)) < 0)
464  return ret;
465  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8, linesize_a)) < 0)
466  return ret;
467  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a, linesize_a)) < 0)
468  return ret;
469  if ((ret = decode_dct_block(s, &gb, last_dc, 3, dest_a + 8 * linesize_a + 8, linesize_a)) < 0)
470  return ret;
471  dest_a += 16;
472  }
473  }
474  }
475  }
476 
477  if (s->subsampling != SHQ_SUBSAMPLING_444 && (frame->width & 15))
478  return decode_speedhq_border(s, &gb, frame, field_number, line_stride);
479 
480  return 0;
481 }
482 
483 static void compute_quant_matrix(int *output, int qscale)
484 {
485  int i;
486  for (i = 0; i < 64; i++) output[i] = unscaled_quant_matrix[ff_zigzag_direct[i]] * qscale;
487 }
488 
489 static int speedhq_decode_frame(AVCodecContext *avctx,
490  void *data, int *got_frame,
491  AVPacket *avpkt)
492 {
493  SHQContext * const s = avctx->priv_data;
494  const uint8_t *buf = avpkt->data;
495  int buf_size = avpkt->size;
496  AVFrame *frame = data;
497  uint8_t quality;
498  uint32_t second_field_offset;
499  int ret;
500 
501  if (buf_size < 4 || avctx->width < 8)
502  return AVERROR_INVALIDDATA;
503 
504  quality = buf[0];
505  if (quality >= 100) {
506  return AVERROR_INVALIDDATA;
507  }
508 
509  compute_quant_matrix(s->quant_matrix, 100 - quality);
510 
511  second_field_offset = AV_RL24(buf + 1);
512  if (second_field_offset >= buf_size - 3) {
513  return AVERROR_INVALIDDATA;
514  }
515 
516  avctx->coded_width = FFALIGN(avctx->width, 16);
517  avctx->coded_height = FFALIGN(avctx->height, 16);
518 
519  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
520  return ret;
521  }
522  frame->key_frame = 1;
523 
524  if (second_field_offset == 4 || second_field_offset == (buf_size-4)) {
525  /*
526  * Overlapping first and second fields is used to signal
527  * encoding only a single field. In this case, "height"
528  * is ambiguous; it could mean either the height of the
529  * frame as a whole, or of the field. The former would make
530  * more sense for compatibility with legacy decoders,
531  * but this matches the convention used in NDI, which is
532  * the primary user of this trick.
533  */
534  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, buf_size, 1)) < 0)
535  return ret;
536  } else {
537  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 0, 4, second_field_offset, 2)) < 0)
538  return ret;
539  if ((ret = decode_speedhq_field(s, buf, buf_size, frame, 1, second_field_offset, buf_size, 2)) < 0)
540  return ret;
541  }
542 
543  *got_frame = 1;
544  return buf_size;
545 }
546 
547 /*
548  * Alpha VLC. Run and level are independently coded, and would be
549  * outside the default limits for MAX_RUN/MAX_LEVEL, so we don't
550  * bother with combining them into one table.
551  */
552 static av_cold void compute_alpha_vlcs(void)
553 {
554  uint16_t run_code[134], level_code[266];
555  uint8_t run_bits[134], level_bits[266];
556  int16_t run_symbols[134], level_symbols[266];
557  int entry, i, sign;
558 
559  /* Initialize VLC for alpha run. */
560  entry = 0;
561 
562  /* 0 -> 0. */
563  run_code[entry] = 0;
564  run_bits[entry] = 1;
565  run_symbols[entry] = 0;
566  ++entry;
567 
568  /* 10xx -> xx plus 1. */
569  for (i = 0; i < 4; ++i) {
570  run_code[entry] = (i << 2) | 1;
571  run_bits[entry] = 4;
572  run_symbols[entry] = i + 1;
573  ++entry;
574  }
575 
576  /* 111xxxxxxx -> xxxxxxx. */
577  for (i = 0; i < 128; ++i) {
578  run_code[entry] = (i << 3) | 7;
579  run_bits[entry] = 10;
580  run_symbols[entry] = i;
581  ++entry;
582  }
583 
584  /* 110 -> EOB. */
585  run_code[entry] = 3;
586  run_bits[entry] = 3;
587  run_symbols[entry] = -1;
588  ++entry;
589 
590  av_assert0(entry == FF_ARRAY_ELEMS(run_code));
591 
592  INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_run_vlc_le, ALPHA_VLC_BITS,
593  FF_ARRAY_ELEMS(run_code),
594  run_bits, 1, 1,
595  run_code, 2, 2,
596  run_symbols, 2, 2, 160);
597 
598  /* Initialize VLC for alpha level. */
599  entry = 0;
600 
601  for (sign = 0; sign <= 1; ++sign) {
602  /* 1s -> -1 or +1 (depending on sign bit). */
603  level_code[entry] = (sign << 1) | 1;
604  level_bits[entry] = 2;
605  level_symbols[entry] = sign ? -1 : 1;
606  ++entry;
607 
608  /* 01sxx -> xx plus 2 (2..5 or -2..-5, depending on sign bit). */
609  for (i = 0; i < 4; ++i) {
610  level_code[entry] = (i << 3) | (sign << 2) | 2;
611  level_bits[entry] = 5;
612  level_symbols[entry] = sign ? -(i + 2) : (i + 2);
613  ++entry;
614  }
615  }
616 
617  /*
618  * 00xxxxxxxx -> xxxxxxxx, in two's complement. There are many codes
619  * here that would better be encoded in other ways (e.g. 0 would be
620  * encoded by increasing run, and +/- 1 would be encoded with a
621  * shorter code), but it doesn't hurt to allow everything.
622  */
623  for (i = 0; i < 256; ++i) {
624  level_code[entry] = i << 2;
625  level_bits[entry] = 10;
626  level_symbols[entry] = i;
627  ++entry;
628  }
629 
630  av_assert0(entry == FF_ARRAY_ELEMS(level_code));
631 
632  INIT_LE_VLC_SPARSE_STATIC(&dc_alpha_level_vlc_le, ALPHA_VLC_BITS,
633  FF_ARRAY_ELEMS(level_code),
634  level_bits, 1, 1,
635  level_code, 2, 2,
636  level_symbols, 2, 2, 288);
637 }
638 
639 static av_cold void speedhq_static_init(void)
640 {
641  /* Exactly the same as MPEG-2, except for a little-endian reader. */
642  INIT_CUSTOM_VLC_STATIC(&dc_lum_vlc_le, DC_VLC_BITS, 12,
645  INIT_VLC_OUTPUT_LE, 512);
646  INIT_CUSTOM_VLC_STATIC(&dc_chroma_vlc_le, DC_VLC_BITS, 12,
649  INIT_VLC_OUTPUT_LE, 514);
650 
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 
728  .name = "speedhq",
729  .long_name = NULL_IF_CONFIG_SMALL("NewTek SpeedHQ"),
730  .type = AVMEDIA_TYPE_VIDEO,
731  .id = AV_CODEC_ID_SPEEDHQ,
732  .priv_data_size = sizeof(SHQContext),
733  .init = speedhq_decode_init,
734  .decode = speedhq_decode_frame,
735  .capabilities = AV_CODEC_CAP_DR1,
736 };
737 #endif /* CONFIG_SPEEDHQ_DECODER */
static void compute_quant_matrix(AGMContext *s, double qscale)
Definition: agm.c:534
AVCodec ff_speedhq_decoder
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
uint8_t
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define AV_RL24
Definition: intreadwrite.h:78
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
#define MKTAG(a, b, c, d)
Definition: common.h:478
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
float re
Definition: fft.c:82
bitstream reader API header.
#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
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 CLOSE_READER(name, gb)
Definition: get_bits.h:149
static int get_xbits_le(GetBitContext *s, int n)
Definition: get_bits.h:344
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:738
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
#define UPDATE_CACHE_LE(name, gb)
Definition: get_bits.h:161
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
@ AV_CODEC_ID_SPEEDHQ
Definition: codec_id.h:274
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
int i
Definition: input.c:407
#define DC_VLC_BITS
Definition: intrax8.c:40
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#define TEX_VLC_BITS
Definition: dv.h:99
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
#define FFALIGN(x, a)
Definition: macros.h:48
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
#define INIT_2D_VLC_RL(rl, static_size, flags)
Definition: mpeg12.h:30
const uint16_t ff_mpeg12_vlc_dc_chroma_code[12]
Definition: mpeg12data.c:59
const uint16_t ff_mpeg12_vlc_dc_lum_code[12]
Definition: mpeg12data.c:52
const unsigned char ff_mpeg12_vlc_dc_chroma_bits[12]
Definition: mpeg12data.c:62
const unsigned char ff_mpeg12_vlc_dc_lum_bits[12]
Definition: mpeg12data.c:55
MPEG-1/2 tables.
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2033
MPEG-1/2 VLC.
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 char data[16]
Definition: mxf.c:142
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:608
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
@ 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:518
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
#define MAX_LEVEL
Definition: rl.h:36
#define MAX_RUN
Definition: rl.h:35
#define FF_ARRAY_ELEMS(a)
const uint8_t * code
Definition: spdifenc.c:413
static const uint8_t speedhq_run[121]
Definition: speedhq.c:118
static const uint8_t speedhq_level[121]
Definition: speedhq.c:99
RLTable ff_rl_speedhq
Definition: speedhq.c:137
static const uint16_t speedhq_vlc[123][2]
Definition: speedhq.c:63
#define ALPHA_VLC_BITS
Definition: speedhq.c:48
#define MAX_INDEX
Definition: speedhq.c:42
static uint8_t speedhq_static_rl_table_store[2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: speedhqenc.c:39
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
int coded_height
Definition: avcodec.h:724
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1178
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:724
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int width
Definition: frame.h:376
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int height
Definition: frame.h:376
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
RLTable.
Definition: rl.h:39
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
BlockDSPContext bdsp
Definition: speedhq.c:52
@ SHQ_DCT_ALPHA
Definition: speedhq.c:58
@ SHQ_NO_ALPHA
Definition: speedhq.c:58
@ SHQ_RLE_ALPHA
Definition: speedhq.c:58
enum SHQContext::@133 alpha_type
@ SHQ_SUBSAMPLING_420
Definition: speedhq.c:56
@ SHQ_SUBSAMPLING_444
Definition: speedhq.c:56
@ SHQ_SUBSAMPLING_422
Definition: speedhq.c:56
ScanTable intra_scantable
Definition: speedhq.c:54
AVCodecContext * avctx
Definition: speedhq.c:51
IDCTDSPContext idsp
Definition: speedhq.c:53
enum SHQContext::@132 subsampling
int quant_matrix[64]
Definition: speedhq.c:55
Scantable.
Definition: idctdsp.h:31
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
uint8_t run
Definition: svq3.c:205
uint8_t level
Definition: svq3.c:206
#define av_log(a,...)
static int16_t block[64]
Definition: dct.c:116
#define width
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define INIT_CUSTOM_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, flags, static_size)
Definition: vlc.h:116
#define INIT_VLC_LE
Definition: vlc.h:94
#define INIT_VLC_OUTPUT_LE
Definition: vlc.h:93
#define INIT_LE_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:112