FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
hqx.c
Go to the documentation of this file.
1 /*
2  * Canopus HQX decoder
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <inttypes.h>
22 
23 #include "libavutil/frame.h"
24 #include "libavutil/imgutils.h"
25 #include "libavutil/mem_internal.h"
26 #include "libavutil/intreadwrite.h"
27 #include "libavutil/thread.h"
28 
29 #include "avcodec.h"
30 #include "canopus.h"
31 #include "codec_internal.h"
32 #include "get_bits.h"
33 #include "thread.h"
34 #include "vlc.h"
35 
36 #include "hqxdsp.h"
37 #include "hqxvlc.h"
38 #include "hq_common.h"
39 
40 /* HQX has four modes - 422, 444, 422alpha and 444alpha - all 12-bit */
41 enum HQXFormat {
42  HQX_422 = 0,
46 };
47 
48 struct HQXContext;
49 
50 typedef int (*mb_decode_func)(struct HQXContext *ctx,
51  int slice_no, int x, int y);
52 
53 typedef struct HQXSlice {
55  DECLARE_ALIGNED(16, int16_t, block)[16][64];
56 } HQXSlice;
57 
58 typedef struct HQXContext {
61 
64 
67 
68  const uint8_t *src;
69  unsigned int data_size;
70  uint32_t slice_off[17];
71 
72  const VLCElem *dc_vlc;
73 
75 } HQXContext;
76 
77 #define HQX_HEADER_SIZE 59
78 
79 #define AC_IDX(q) ((q) >= 128 ? HQX_AC_Q128 : (q) >= 64 ? HQX_AC_Q64 : \
80  (q) >= 32 ? HQX_AC_Q32 : (q) >= 16 ? HQX_AC_Q16 : \
81  (q) >= 8 ? HQX_AC_Q8 : HQX_AC_Q0)
82 
83 /* macroblock selects a group of 4 possible quants and
84  * a block can use any of those four quantisers
85  * one column is powers of 2, the other one is powers of 2 * 3,
86  * then there is the special one, powers of 2 * 5.
87  * We also encode the corresponding AC index in these tables in bits 29-31. */
88 static const unsigned hqx_quants[16][4] = {
89 #define Q(q) ((unsigned)AC_IDX(q) << 29 | (q))
90  { Q( 0x1), Q( 0x2), Q( 0x4), Q( 0x8) }, { Q( 0x1), Q( 0x3), Q( 0x6), Q( 0xC) },
91  { Q( 0x2), Q( 0x4), Q( 0x8), Q( 0x10) }, { Q( 0x3), Q( 0x6), Q( 0xC), Q( 0x18) },
92  { Q( 0x4), Q( 0x8), Q( 0x10), Q( 0x20) }, { Q( 0x6), Q( 0xC), Q( 0x18), Q( 0x30) },
93  { Q( 0x8), Q( 0x10), Q( 0x20), Q( 0x40) },
94  { Q(0xA), Q(0x14), Q(0x28), Q(0x50) },
95  { Q( 0xC), Q(0x18), Q( 0x30), Q( 0x60) },
96  { Q(0x10), Q( 0x20), Q( 0x40), Q( 0x80) }, { Q(0x18), Q(0x30), Q( 0x60), Q( 0xC0) },
97  { Q(0x20), Q( 0x40), Q( 0x80), Q(0x100) }, { Q(0x30), Q(0x60), Q( 0xC0), Q(0x180) },
98  { Q(0x40), Q( 0x80), Q(0x100), Q(0x200) }, { Q(0x60), Q(0xC0), Q(0x180), Q(0x300) },
99  { Q(0x80), Q(0x100), Q(0x200), Q(0x400) }
100 };
101 
102 static const uint8_t hqx_quant_luma[64] = {
103  16, 16, 16, 19, 19, 19, 42, 44,
104  16, 16, 19, 19, 19, 38, 43, 45,
105  16, 19, 19, 19, 40, 41, 45, 48,
106  19, 19, 19, 40, 41, 42, 46, 49,
107  19, 19, 40, 41, 42, 43, 48, 101,
108  19, 38, 41, 42, 43, 44, 98, 104,
109  42, 43, 45, 46, 48, 98, 109, 116,
110  44, 45, 48, 49, 101, 104, 116, 123,
111 };
112 
113 static const uint8_t hqx_quant_chroma[64] = {
114  16, 16, 19, 25, 26, 26, 42, 44,
115  16, 19, 25, 25, 26, 38, 43, 91,
116  19, 25, 26, 27, 40, 41, 91, 96,
117  25, 25, 27, 40, 41, 84, 93, 197,
118  26, 26, 40, 41, 84, 86, 191, 203,
119  26, 38, 41, 84, 86, 177, 197, 209,
120  42, 43, 91, 93, 191, 197, 219, 232,
121  44, 91, 96, 197, 203, 209, 232, 246,
122 };
123 
124 static inline void put_blocks(HQXContext *ctx, int plane,
125  int x, int y, int ilace,
126  int16_t *block0, int16_t *block1,
127  const uint8_t *quant)
128 {
129  int fields = ilace ? 2 : 1;
130  int lsize = ctx->pic->linesize[plane];
131  uint8_t *p = ctx->pic->data[plane] + x * 2;
132 
133  ctx->hqxdsp.idct_put((uint16_t *)(p + y * lsize),
134  lsize * fields, block0, quant);
135  ctx->hqxdsp.idct_put((uint16_t *)(p + (y + (ilace ? 1 : 8)) * lsize),
136  lsize * fields, block1, quant);
137 }
138 
139 static inline void hqx_get_ac(GetBitContext *gb, const HQXAC *ac,
140  int *runp, int *lev)
141 {
142  int level, run;
143  OPEN_READER(re, gb);
144 
145  UPDATE_CACHE(re, gb);
146  GET_RL_VLC(level, run, re, gb, ac->lut, ac->bits, 2, 0);
147  CLOSE_READER(re, gb);
148  *runp = run;
149  *lev = level;
150 }
151 
152 static int decode_block(GetBitContext *gb, const VLCElem vlc[],
153  const unsigned *quants, int dcb,
154  int16_t block[64], int *last_dc)
155 {
156  int run, lev, pos = 0;
157  unsigned ac_idx, q;
158  int dc;
159 
160  dc = get_vlc2(gb, vlc, HQX_DC_VLC_BITS, 2);
161  *last_dc += dc;
162 
163  block[0] = sign_extend(*last_dc << (12 - dcb), 12);
164 
165  q = quants[get_bits(gb, 2)];
166  // ac_idx is encoded in the high bits of quants;
167  // because block is 16 bit, we do not even need to clear said bits.
168  ac_idx = q >> 29;
169 
170  do {
171  hqx_get_ac(gb, &hqx_ac[ac_idx], &run, &lev);
172  pos += run;
173  if (pos > 63)
174  break;
175  block[ff_zigzag_direct[pos]] = lev * q;
176  } while (pos < 63);
177 
178  return 0;
179 }
180 
181 static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
182 {
183  HQXSlice *slice = &ctx->slice[slice_no];
184  GetBitContext *gb = &slice->gb;
185  const unsigned *quants;
186  int flag;
187  int last_dc;
188  int i, ret;
189 
190  memset(slice->block, 0, sizeof(*slice->block) * 8);
191 
192  if (ctx->interlaced)
193  flag = get_bits1(gb);
194  else
195  flag = 0;
196 
197  quants = hqx_quants[get_bits(gb, 4)];
198 
199  for (i = 0; i < 8; i++) {
200  if (i == 0 || i == 4 || i == 6)
201  last_dc = 0;
202  ret = decode_block(gb, ctx->dc_vlc, quants,
203  ctx->dcb, slice->block[i], &last_dc);
204  if (ret < 0)
205  return ret;
206  }
207 
208  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[2], hqx_quant_luma);
209  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[3], hqx_quant_luma);
210  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[4], slice->block[5], hqx_quant_chroma);
211  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[6], slice->block[7], hqx_quant_chroma);
212 
213  return 0;
214 }
215 
216 static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
217 {
218  HQXSlice *slice = &ctx->slice[slice_no];
219  GetBitContext *gb = &slice->gb;
220  int flag = 0;
221  int last_dc;
222  int i, ret;
223 
224  memset(slice->block, 0, sizeof(*slice->block) * 12);
225  for (i = 0; i < 12; i++)
226  slice->block[i][0] = -0x800;
227 
228  int cbp = get_vlc2(gb, ff_hq_cbp_vlc, HQ_CBP_VLC_BITS, 1);
229  if (cbp) {
230  const unsigned *quants;
231 
232  if (ctx->interlaced)
233  flag = get_bits1(gb);
234 
235  quants = hqx_quants[get_bits(gb, 4)];
236 
237  if (cbp & 0x3) // chroma CBP - top
238  cbp |= 0x500;
239  if (cbp & 0xC) // chroma CBP - bottom
240  cbp |= 0xA00;
241  for (i = 0; i < 12; i++) {
242  if (i == 0 || i == 4 || i == 8 || i == 10)
243  last_dc = 0;
244  if (cbp & (1 << i)) {
245  ret = decode_block(gb, ctx->dc_vlc, quants,
246  ctx->dcb, slice->block[i], &last_dc);
247  if (ret < 0)
248  return ret;
249  }
250  }
251  }
252 
253  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
254  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
255  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
256  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
257  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[ 8], slice->block[ 9], hqx_quant_chroma);
258  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[10], slice->block[11], hqx_quant_chroma);
259 
260  return 0;
261 }
262 
263 static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
264 {
265  HQXSlice *slice = &ctx->slice[slice_no];
266  GetBitContext *gb = &slice->gb;
267  const unsigned *quants;
268  int flag;
269  int last_dc;
270  int i, ret;
271 
272  memset(slice->block, 0, sizeof(*slice->block) * 12);
273 
274  if (ctx->interlaced)
275  flag = get_bits1(gb);
276  else
277  flag = 0;
278 
279  quants = hqx_quants[get_bits(gb, 4)];
280 
281  for (i = 0; i < 12; i++) {
282  if (!(i & 3))
283  last_dc = 0;
284  ret = decode_block(gb, ctx->dc_vlc, quants,
285  ctx->dcb, slice->block[i], &last_dc);
286  if (ret < 0)
287  return ret;
288  }
289 
290  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[ 2], hqx_quant_luma);
291  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[ 3], hqx_quant_luma);
292  put_blocks(ctx, 2, x, y, flag, slice->block[4], slice->block[ 6], hqx_quant_chroma);
293  put_blocks(ctx, 2, x + 8, y, flag, slice->block[5], slice->block[ 7], hqx_quant_chroma);
294  put_blocks(ctx, 1, x, y, flag, slice->block[8], slice->block[10], hqx_quant_chroma);
295  put_blocks(ctx, 1, x + 8, y, flag, slice->block[9], slice->block[11], hqx_quant_chroma);
296 
297  return 0;
298 }
299 
300 static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
301 {
302  HQXSlice *slice = &ctx->slice[slice_no];
303  GetBitContext *gb = &slice->gb;
304  int flag = 0;
305  int last_dc;
306  int i, ret;
307 
308  memset(slice->block, 0, sizeof(*slice->block) * 16);
309  for (i = 0; i < 16; i++)
310  slice->block[i][0] = -0x800;
311 
312  int cbp = get_vlc2(gb, ff_hq_cbp_vlc, HQ_CBP_VLC_BITS, 1);
313  if (cbp) {
314  const unsigned *quants;
315 
316  if (ctx->interlaced)
317  flag = get_bits1(gb);
318 
319  quants = hqx_quants[get_bits(gb, 4)];
320 
321  cbp |= cbp << 8; // chroma CBP
322  for (i = 0; i < 16; i++) {
323  if (!(i & 3))
324  last_dc = 0;
325  if (cbp & (1 << i)) {
326  ret = decode_block(gb, ctx->dc_vlc, quants,
327  ctx->dcb, slice->block[i], &last_dc);
328  if (ret < 0)
329  return ret;
330  }
331  }
332  }
333 
334  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
335  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
336  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
337  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
338  put_blocks(ctx, 2, x, y, flag, slice->block[ 8], slice->block[10], hqx_quant_chroma);
339  put_blocks(ctx, 2, x + 8, y, flag, slice->block[ 9], slice->block[11], hqx_quant_chroma);
340  put_blocks(ctx, 1, x, y, flag, slice->block[12], slice->block[14], hqx_quant_chroma);
341  put_blocks(ctx, 1, x + 8, y, flag, slice->block[13], slice->block[15], hqx_quant_chroma);
342 
343  return 0;
344 }
345 
346 static const int shuffle_16[16] = {
347  0, 5, 11, 14, 2, 7, 9, 13, 1, 4, 10, 15, 3, 6, 8, 12
348 };
349 
350 static int decode_slice(HQXContext *ctx, int slice_no)
351 {
352  int mb_w = (ctx->width + 15) >> 4;
353  int mb_h = (ctx->height + 15) >> 4;
354  int grp_w = (mb_w + 4) / 5;
355  int grp_h = (mb_h + 4) / 5;
356  int grp_h_edge = grp_w * (mb_w / grp_w);
357  int grp_v_edge = grp_h * (mb_h / grp_h);
358  int grp_v_rest = mb_w - grp_h_edge;
359  int grp_h_rest = mb_h - grp_v_edge;
360  int num_mbs = mb_w * mb_h;
361  int num_tiles = (num_mbs + 479) / 480;
362  int std_tile_blocks = num_mbs / (16 * num_tiles);
363  int g_tile = slice_no * num_tiles;
364  int blk_addr, loc_addr, mb_x, mb_y, pos, loc_row, i;
365  int tile_blocks, tile_limit, tile_no;
366 
367  for (tile_no = 0; tile_no < num_tiles; tile_no++, g_tile++) {
368  tile_blocks = std_tile_blocks;
369  tile_limit = -1;
370  if (g_tile < num_mbs - std_tile_blocks * 16 * num_tiles) {
371  tile_limit = num_mbs / (16 * num_tiles);
372  tile_blocks++;
373  }
374  for (i = 0; i < tile_blocks; i++) {
375  if (i == tile_limit)
376  blk_addr = g_tile + 16 * num_tiles * i;
377  else
378  blk_addr = tile_no + 16 * num_tiles * i +
379  num_tiles * shuffle_16[(i + slice_no) & 0xF];
380  loc_row = grp_h * (blk_addr / (grp_h * mb_w));
381  loc_addr = blk_addr % (grp_h * mb_w);
382  if (loc_row >= grp_v_edge) {
383  mb_x = grp_w * (loc_addr / (grp_h_rest * grp_w));
384  pos = loc_addr % (grp_h_rest * grp_w);
385  } else {
386  mb_x = grp_w * (loc_addr / (grp_h * grp_w));
387  pos = loc_addr % (grp_h * grp_w);
388  }
389  if (mb_x >= grp_h_edge) {
390  mb_x += pos % grp_v_rest;
391  mb_y = loc_row + (pos / grp_v_rest);
392  } else {
393  mb_x += pos % grp_w;
394  mb_y = loc_row + (pos / grp_w);
395  }
396  ctx->decode_func(ctx, slice_no, mb_x * 16, mb_y * 16);
397  }
398  }
399 
400  return 0;
401 }
402 
403 static int decode_slice_thread(AVCodecContext *avctx, void *arg,
404  int slice_no, int threadnr)
405 {
406  HQXContext *ctx = avctx->priv_data;
407  uint32_t *slice_off = ctx->slice_off;
408  int ret;
409 
410  if (slice_off[slice_no] < HQX_HEADER_SIZE ||
411  slice_off[slice_no] >= slice_off[slice_no + 1] ||
412  slice_off[slice_no + 1] > ctx->data_size) {
413  av_log(avctx, AV_LOG_ERROR, "Invalid slice size %d.\n", ctx->data_size);
414  return AVERROR_INVALIDDATA;
415  }
416 
417  ret = init_get_bits8(&ctx->slice[slice_no].gb,
418  ctx->src + slice_off[slice_no],
419  slice_off[slice_no + 1] - slice_off[slice_no]);
420  if (ret < 0)
421  return ret;
422 
423  return decode_slice(ctx, slice_no);
424 }
425 
427  int *got_picture_ptr, AVPacket *avpkt)
428 {
429  HQXContext *ctx = avctx->priv_data;
430  const uint8_t *src = avpkt->data;
431  uint32_t info_tag;
432  int data_start, dcb_code;
433  int i, ret;
434 
435  if (avpkt->size < 4 + 4) {
436  av_log(avctx, AV_LOG_ERROR, "Frame is too small %d.\n", avpkt->size);
437  return AVERROR_INVALIDDATA;
438  }
439 
440  info_tag = AV_RL32(src);
441  if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
442  uint32_t info_offset = AV_RL32(src + 4);
443  if (info_offset > INT_MAX || info_offset + 8 > avpkt->size) {
444  av_log(avctx, AV_LOG_ERROR,
445  "Invalid INFO header offset: 0x%08"PRIX32" is too large.\n",
446  info_offset);
447  return AVERROR_INVALIDDATA;
448  }
449  ff_canopus_parse_info_tag(avctx, src + 8, info_offset);
450 
451  info_offset += 8;
452  src += info_offset;
453  }
454 
455  data_start = src - avpkt->data;
456  ctx->data_size = avpkt->size - data_start;
457  ctx->src = src;
458  ctx->pic = frame;
459 
460  if (ctx->data_size < HQX_HEADER_SIZE) {
461  av_log(avctx, AV_LOG_ERROR, "Frame too small.\n");
462  return AVERROR_INVALIDDATA;
463  }
464 
465  if (src[0] != 'H' || src[1] != 'Q') {
466  av_log(avctx, AV_LOG_ERROR, "Not an HQX frame.\n");
467  return AVERROR_INVALIDDATA;
468  }
469  ctx->interlaced = !(src[2] & 0x80);
470  ctx->format = src[2] & 7;
471  dcb_code = src[3] & 3;
472  ctx->width = AV_RB16(src + 4);
473  ctx->height = AV_RB16(src + 6);
474  for (i = 0; i < 17; i++)
475  ctx->slice_off[i] = AV_RB24(src + 8 + i * 3);
476 
477  if (dcb_code == 0) {
478  av_log(avctx, AV_LOG_ERROR, "Invalid DC precision 8.\n");
479  return AVERROR_INVALIDDATA;
480  }
481  ctx->dc_vlc = dcb_code == 3 ? ctx->dc11_vlc.table : dc_vlc[dcb_code - 1];
482  ctx->dcb = dcb_code + 8;
483  ret = av_image_check_size(ctx->width, ctx->height, 0, avctx);
484  if (ret < 0) {
485  av_log(avctx, AV_LOG_ERROR, "Invalid stored dimensions %dx%d.\n",
486  ctx->width, ctx->height);
487  return AVERROR_INVALIDDATA;
488  }
489 
490  avctx->coded_width = FFALIGN(ctx->width, 16);
491  avctx->coded_height = FFALIGN(ctx->height, 16);
492  avctx->width = ctx->width;
493  avctx->height = ctx->height;
494  avctx->bits_per_raw_sample = 10;
495 
496  //The minimum size is 2bit per macroblock
497  // hqx_decode_422 & hqx_decode_444 have a unconditionally stored 4bits hqx_quants index
498  // hqx_decode_422a & hqx_decode_444a use cbp_vlc which has a minimum length of 2 bits for its VLCs
499  // The code rejects slices overlapping in their input data
500  if (avctx->coded_width / 16 * (avctx->coded_height / 16) *
501  (100 - avctx->discard_damaged_percentage) / 100 > 4LL * avpkt->size)
502  return AVERROR_INVALIDDATA;
503 
504  switch (ctx->format) {
505  case HQX_422:
506  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
507  ctx->decode_func = hqx_decode_422;
508  break;
509  case HQX_444:
510  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
511  ctx->decode_func = hqx_decode_444;
512  break;
513  case HQX_422A:
515  ctx->decode_func = hqx_decode_422a;
516  break;
517  case HQX_444A:
519  ctx->decode_func = hqx_decode_444a;
520  break;
521  default:
522  av_log(avctx, AV_LOG_ERROR, "Invalid format: %d.\n", ctx->format);
523  return AVERROR_INVALIDDATA;
524  }
525 
526  ret = ff_thread_get_buffer(avctx, frame, 0);
527  if (ret < 0)
528  return ret;
529 
530  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, 16);
531 
532  *got_picture_ptr = 1;
533 
534  return avpkt->size;
535 }
536 
538 {
539  HQXContext *ctx = avctx->priv_data;
540 
541  ff_vlc_free(&ctx->dc11_vlc);
542 
543  return 0;
544 }
545 
547 {
548  static AVOnce init_static_once = AV_ONCE_INIT;
549  HQXContext *ctx = avctx->priv_data;
551  dc11_vlc_lens, 1, 1, dc11_vlc_bits, 2, 2, 0);
552 
553  if (ret < 0)
554  return ret;
555 
556  ff_hqxdsp_init(&ctx->hqxdsp);
557 
558  ff_thread_once(&init_static_once, hqx_init_static);
559 
560  return 0;
561 }
562 
564  .p.name = "hqx",
565  CODEC_LONG_NAME("Canopus HQX"),
566  .p.type = AVMEDIA_TYPE_VIDEO,
567  .p.id = AV_CODEC_ID_HQX,
568  .priv_data_size = sizeof(HQXContext),
571  .close = hqx_decode_close,
572  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
574  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
575 };
hqx_get_ac
static void hqx_get_ac(GetBitContext *gb, const HQXAC *ac, int *runp, int *lev)
Definition: hqx.c:139
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:579
hqx_decode_init
static av_cold int hqx_decode_init(AVCodecContext *avctx)
Definition: hqx.c:546
level
uint8_t level
Definition: svq3.c:205
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
HQXContext::data_size
unsigned int data_size
Definition: hqx.c:69
HQXContext::hqxdsp
HQXDSPContext hqxdsp
Definition: hqx.c:59
hqx_decode_422a
static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:216
mem_internal.h
ff_hqx_decoder
const FFCodec ff_hqx_decoder
Definition: hqx.c:563
HQX_422
@ HQX_422
Definition: hqx.c:42
HQXSlice::gb
GetBitContext gb
Definition: hqx.c:54
thread.h
HQXAC::bits
int bits
Definition: hqxvlc.h:44
HQXContext::width
int width
Definition: hqx.c:65
HQXContext::pic
AVFrame * pic
Definition: hqx.c:62
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
HQ_CBP_VLC_BITS
#define HQ_CBP_VLC_BITS
Definition: hq_common.h:25
AVPacket::data
uint8_t * data
Definition: packet.h:535
hqx_decode_422
static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:181
hqx_decode_close
static av_cold int hqx_decode_close(AVCodecContext *avctx)
Definition: hqx.c:537
FFCodec
Definition: codec_internal.h:127
HQXContext::decode_func
mb_decode_func decode_func
Definition: hqx.c:63
HQX_DC_VLC_BITS
#define HQX_DC_VLC_BITS
Definition: hqxvlc.h:31
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:208
thread.h
ff_hqxdsp_init
av_cold void ff_hqxdsp_init(HQXDSPContext *c)
Definition: hqxdsp.c:128
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int slice_no, int threadnr)
Definition: hqx.c:403
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
ff_hq_cbp_vlc
const VLCElem ff_hq_cbp_vlc[1<< HQ_CBP_VLC_BITS]
Definition: hq_common.c:27
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
hqx_quant_luma
static const uint8_t hqx_quant_luma[64]
Definition: hqx.c:102
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:580
ff_canopus_parse_info_tag
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
Definition: canopus.c:30
GetBitContext
Definition: get_bits.h:108
hqx_quant_chroma
static const uint8_t hqx_quant_chroma[64]
Definition: hqx.c:113
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
hqx_ac
static HQXAC hqx_ac[NUM_HQX_AC]
Definition: hqxvlc.h:739
Q
#define Q(q)
quant
static const uint8_t quant[64]
Definition: vmixdec.c:71
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:540
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:184
HQXContext::slice
HQXSlice slice[16]
Definition: hqx.c:60
HQXDSPContext
Definition: hqxdsp.h:32
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
intreadwrite.h
HQX_444
@ HQX_444
Definition: hqx.c:43
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:541
hqx_decode_444
static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:263
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1048
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:70
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1553
ctx
AVFormatContext * ctx
Definition: movenc.c:49
get_bits.h
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
arg
const char * arg
Definition: jacosubdec.c:67
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
dc_vlc
static VLCElem dc_vlc[1104]
Definition: clearvideo.c:79
hqxvlc.h
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
HQX_HEADER_SIZE
#define HQX_HEADER_SIZE
Definition: hqx.c:77
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:204
HQXContext::dc11_vlc
VLC dc11_vlc
Definition: hqx.c:74
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
HQXContext::dcb
int dcb
Definition: hqx.c:65
hqx_init_static
static av_cold av_unused void hqx_init_static(void)
Definition: hqxvlc.h:1534
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:635
canopus.h
hqx_quants
static const unsigned hqx_quants[16][4]
Definition: hqx.c:88
AVOnce
#define AVOnce
Definition: thread.h:202
HQXAC::lut
const RL_VLC_ELEM * lut
Definition: hqxvlc.h:45
HQXSlice
Definition: hqx.c:53
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:536
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
VLCElem
Definition: vlc.h:32
dc11_vlc_lens
static const uint8_t dc11_vlc_lens[2048]
Definition: hqxvlc.h:607
put_blocks
static void put_blocks(HQXContext *ctx, int plane, int x, int y, int ilace, int16_t *block0, int16_t *block1, const uint8_t *quant)
Definition: hqx.c:124
frame.h
hqxdsp.h
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:173
block1
static int16_t block1[64]
Definition: dct.c:121
mb_decode_func
int(* mb_decode_func)(struct HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:50
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
HQXContext
Definition: hqx.c:58
shuffle_16
static const int shuffle_16[16]
Definition: hqx.c:346
HQXSlice::block
int16_t block[16][64]
Definition: hqx.c:55
HQXContext::format
int format
Definition: hqx.c:65
hqx_decode_444a
static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:300
AV_CODEC_ID_HQX
@ AV_CODEC_ID_HQX
Definition: codec_id.h:240
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
HQXContext::slice_off
uint32_t slice_off[17]
Definition: hqx.c:70
lev
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:80
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
avcodec.h
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:589
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
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
HQXContext::interlaced
int interlaced
Definition: hqx.c:66
pos
unsigned int pos
Definition: spdifenc.c:414
decode_slice
static int decode_slice(HQXContext *ctx, int slice_no)
Definition: hqx.c:350
flag
#define flag(name)
Definition: cbs_av1.c:495
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
dc11_vlc_bits
static const uint16_t dc11_vlc_bits[2048]
Definition: hqxvlc.h:348
HQX_444A
@ HQX_444A
Definition: hqx.c:45
AVCodecContext
main external API structure.
Definition: avcodec.h:431
VLC
Definition: vlc.h:50
HQXAC
Definition: hqxvlc.h:43
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:131
decode_block
static int decode_block(GetBitContext *gb, const VLCElem vlc[], const unsigned *quants, int dcb, int16_t block[64], int *last_dc)
Definition: hqx.c:152
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:1817
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
hqx_decode_frame
static int hqx_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_picture_ptr, AVPacket *avpkt)
Definition: hqx.c:426
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
vlc.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
imgutils.h
HQXContext::src
const uint8_t * src
Definition: hqx.c:68
HQXContext::dc_vlc
const VLCElem * dc_vlc
Definition: hqx.c:72
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
HQXFormat
HQXFormat
Definition: hqx.c:41
HQXContext::height
int height
Definition: hqx.c:65
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1610
hq_common.h
src
#define src
Definition: vp8dsp.c:248
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
HQX_422A
@ HQX_422A
Definition: hqx.c:44