FFmpeg  4.4
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/imgutils.h"
24 #include "libavutil/intreadwrite.h"
25 
26 #include "avcodec.h"
27 #include "canopus.h"
28 #include "get_bits.h"
29 #include "internal.h"
30 #include "thread.h"
31 
32 #include "hqx.h"
33 #include "hqxdsp.h"
34 
35 /* HQX has four modes - 422, 444, 422alpha and 444alpha - all 12-bit */
36 enum HQXFormat {
37  HQX_422 = 0,
41 };
42 
43 #define HQX_HEADER_SIZE 59
44 
45 /* macroblock selects a group of 4 possible quants and
46  * a block can use any of those four quantisers
47  * one column is powers of 2, the other one is powers of 2 * 3,
48  * then there is the special one, powers of 2 * 5 */
49 static const int hqx_quants[16][4] = {
50  { 0x1, 0x2, 0x4, 0x8 }, { 0x1, 0x3, 0x6, 0xC },
51  { 0x2, 0x4, 0x8, 0x10 }, { 0x3, 0x6, 0xC, 0x18 },
52  { 0x4, 0x8, 0x10, 0x20 }, { 0x6, 0xC, 0x18, 0x30 },
53  { 0x8, 0x10, 0x20, 0x40 },
54  { 0xA, 0x14, 0x28, 0x50 },
55  { 0xC, 0x18, 0x30, 0x60 },
56  { 0x10, 0x20, 0x40, 0x80 }, { 0x18, 0x30, 0x60, 0xC0 },
57  { 0x20, 0x40, 0x80, 0x100 }, { 0x30, 0x60, 0xC0, 0x180 },
58  { 0x40, 0x80, 0x100, 0x200 }, { 0x60, 0xC0, 0x180, 0x300 },
59  { 0x80, 0x100, 0x200, 0x400 }
60 };
61 
62 static const uint8_t hqx_quant_luma[64] = {
63  16, 16, 16, 19, 19, 19, 42, 44,
64  16, 16, 19, 19, 19, 38, 43, 45,
65  16, 19, 19, 19, 40, 41, 45, 48,
66  19, 19, 19, 40, 41, 42, 46, 49,
67  19, 19, 40, 41, 42, 43, 48, 101,
68  19, 38, 41, 42, 43, 44, 98, 104,
69  42, 43, 45, 46, 48, 98, 109, 116,
70  44, 45, 48, 49, 101, 104, 116, 123,
71 };
72 
73 static const uint8_t hqx_quant_chroma[64] = {
74  16, 16, 19, 25, 26, 26, 42, 44,
75  16, 19, 25, 25, 26, 38, 43, 91,
76  19, 25, 26, 27, 40, 41, 91, 96,
77  25, 25, 27, 40, 41, 84, 93, 197,
78  26, 26, 40, 41, 84, 86, 191, 203,
79  26, 38, 41, 84, 86, 177, 197, 209,
80  42, 43, 91, 93, 191, 197, 219, 232,
81  44, 91, 96, 197, 203, 209, 232, 246,
82 };
83 
84 static inline void put_blocks(HQXContext *ctx, int plane,
85  int x, int y, int ilace,
86  int16_t *block0, int16_t *block1,
87  const uint8_t *quant)
88 {
89  int fields = ilace ? 2 : 1;
90  int lsize = ctx->pic->linesize[plane];
91  uint8_t *p = ctx->pic->data[plane] + x * 2;
92 
93  ctx->hqxdsp.idct_put((uint16_t *)(p + y * lsize),
94  lsize * fields, block0, quant);
95  ctx->hqxdsp.idct_put((uint16_t *)(p + (y + (ilace ? 1 : 8)) * lsize),
96  lsize * fields, block1, quant);
97 }
98 
99 static inline void hqx_get_ac(GetBitContext *gb, const HQXAC *ac,
100  int *run, int *lev)
101 {
102  int val;
103 
104  val = show_bits(gb, ac->lut_bits);
105  if (ac->lut[val].bits == -1) {
106  GetBitContext gb2 = *gb;
107  skip_bits(&gb2, ac->lut_bits);
108  val = ac->lut[val].lev + show_bits(&gb2, ac->extra_bits);
109  }
110  *run = ac->lut[val].run;
111  *lev = ac->lut[val].lev;
112  skip_bits(gb, ac->lut[val].bits);
113 }
114 
115 static int decode_block(GetBitContext *gb, VLC *vlc,
116  const int *quants, int dcb,
117  int16_t block[64], int *last_dc)
118 {
119  int q, dc;
120  int ac_idx;
121  int run, lev, pos = 1;
122 
123  memset(block, 0, 64 * sizeof(*block));
124  dc = get_vlc2(gb, vlc->table, HQX_DC_VLC_BITS, 2);
125  *last_dc += dc;
126 
127  block[0] = sign_extend(*last_dc << (12 - dcb), 12);
128 
129  q = quants[get_bits(gb, 2)];
130  if (q >= 128)
131  ac_idx = HQX_AC_Q128;
132  else if (q >= 64)
133  ac_idx = HQX_AC_Q64;
134  else if (q >= 32)
135  ac_idx = HQX_AC_Q32;
136  else if (q >= 16)
137  ac_idx = HQX_AC_Q16;
138  else if (q >= 8)
139  ac_idx = HQX_AC_Q8;
140  else
141  ac_idx = HQX_AC_Q0;
142 
143  do {
144  hqx_get_ac(gb, &ff_hqx_ac[ac_idx], &run, &lev);
145  pos += run;
146  if (pos >= 64)
147  break;
148  block[ff_zigzag_direct[pos++]] = lev * q;
149  } while (pos < 64);
150 
151  return 0;
152 }
153 
154 static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
155 {
156  HQXSlice *slice = &ctx->slice[slice_no];
157  GetBitContext *gb = &slice->gb;
158  const int *quants;
159  int flag;
160  int last_dc;
161  int i, ret;
162 
163  if (ctx->interlaced)
164  flag = get_bits1(gb);
165  else
166  flag = 0;
167 
168  quants = hqx_quants[get_bits(gb, 4)];
169 
170  for (i = 0; i < 8; i++) {
171  int vlc_index = ctx->dcb - 9;
172  if (i == 0 || i == 4 || i == 6)
173  last_dc = 0;
174  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
175  ctx->dcb, slice->block[i], &last_dc);
176  if (ret < 0)
177  return ret;
178  }
179 
180  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[2], hqx_quant_luma);
181  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[3], hqx_quant_luma);
182  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[4], slice->block[5], hqx_quant_chroma);
183  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[6], slice->block[7], hqx_quant_chroma);
184 
185  return 0;
186 }
187 
188 static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
189 {
190  HQXSlice *slice = &ctx->slice[slice_no];
191  GetBitContext *gb = &slice->gb;
192  const int *quants;
193  int flag = 0;
194  int last_dc;
195  int i, ret;
196  int cbp;
197 
198  cbp = get_vlc2(gb, ctx->cbp_vlc.table, HQX_CBP_VLC_BITS, 1);
199 
200  for (i = 0; i < 12; i++)
201  memset(slice->block[i], 0, sizeof(**slice->block) * 64);
202  for (i = 0; i < 12; i++)
203  slice->block[i][0] = -0x800;
204  if (cbp) {
205  if (ctx->interlaced)
206  flag = get_bits1(gb);
207 
208  quants = hqx_quants[get_bits(gb, 4)];
209 
210  cbp |= cbp << 4; // alpha CBP
211  if (cbp & 0x3) // chroma CBP - top
212  cbp |= 0x500;
213  if (cbp & 0xC) // chroma CBP - bottom
214  cbp |= 0xA00;
215  for (i = 0; i < 12; i++) {
216  if (i == 0 || i == 4 || i == 8 || i == 10)
217  last_dc = 0;
218  if (cbp & (1 << i)) {
219  int vlc_index = ctx->dcb - 9;
220  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
221  ctx->dcb, slice->block[i], &last_dc);
222  if (ret < 0)
223  return ret;
224  }
225  }
226  }
227 
228  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
229  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
230  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
231  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
232  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[ 8], slice->block[ 9], hqx_quant_chroma);
233  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[10], slice->block[11], hqx_quant_chroma);
234 
235  return 0;
236 }
237 
238 static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
239 {
240  HQXSlice *slice = &ctx->slice[slice_no];
241  GetBitContext *gb = &slice->gb;
242  const int *quants;
243  int flag;
244  int last_dc;
245  int i, ret;
246 
247  if (ctx->interlaced)
248  flag = get_bits1(gb);
249  else
250  flag = 0;
251 
252  quants = hqx_quants[get_bits(gb, 4)];
253 
254  for (i = 0; i < 12; i++) {
255  int vlc_index = ctx->dcb - 9;
256  if (i == 0 || i == 4 || i == 8)
257  last_dc = 0;
258  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
259  ctx->dcb, slice->block[i], &last_dc);
260  if (ret < 0)
261  return ret;
262  }
263 
264  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[ 2], hqx_quant_luma);
265  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[ 3], hqx_quant_luma);
266  put_blocks(ctx, 2, x, y, flag, slice->block[4], slice->block[ 6], hqx_quant_chroma);
267  put_blocks(ctx, 2, x + 8, y, flag, slice->block[5], slice->block[ 7], hqx_quant_chroma);
268  put_blocks(ctx, 1, x, y, flag, slice->block[8], slice->block[10], hqx_quant_chroma);
269  put_blocks(ctx, 1, x + 8, y, flag, slice->block[9], slice->block[11], hqx_quant_chroma);
270 
271  return 0;
272 }
273 
274 static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
275 {
276  HQXSlice *slice = &ctx->slice[slice_no];
277  GetBitContext *gb = &slice->gb;
278  const int *quants;
279  int flag = 0;
280  int last_dc;
281  int i, ret;
282  int cbp;
283 
284  cbp = get_vlc2(gb, ctx->cbp_vlc.table, HQX_CBP_VLC_BITS, 1);
285 
286  for (i = 0; i < 16; i++)
287  memset(slice->block[i], 0, sizeof(**slice->block) * 64);
288  for (i = 0; i < 16; i++)
289  slice->block[i][0] = -0x800;
290  if (cbp) {
291  if (ctx->interlaced)
292  flag = get_bits1(gb);
293 
294  quants = hqx_quants[get_bits(gb, 4)];
295 
296  cbp |= cbp << 4; // alpha CBP
297  cbp |= cbp << 8; // chroma CBP
298  for (i = 0; i < 16; i++) {
299  if (i == 0 || i == 4 || i == 8 || i == 12)
300  last_dc = 0;
301  if (cbp & (1 << i)) {
302  int vlc_index = ctx->dcb - 9;
303  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
304  ctx->dcb, slice->block[i], &last_dc);
305  if (ret < 0)
306  return ret;
307  }
308  }
309  }
310 
311  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
312  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
313  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
314  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
315  put_blocks(ctx, 2, x, y, flag, slice->block[ 8], slice->block[10], hqx_quant_chroma);
316  put_blocks(ctx, 2, x + 8, y, flag, slice->block[ 9], slice->block[11], hqx_quant_chroma);
317  put_blocks(ctx, 1, x, y, flag, slice->block[12], slice->block[14], hqx_quant_chroma);
318  put_blocks(ctx, 1, x + 8, y, flag, slice->block[13], slice->block[15], hqx_quant_chroma);
319 
320  return 0;
321 }
322 
323 static const int shuffle_16[16] = {
324  0, 5, 11, 14, 2, 7, 9, 13, 1, 4, 10, 15, 3, 6, 8, 12
325 };
326 
327 static int decode_slice(HQXContext *ctx, int slice_no)
328 {
329  int mb_w = (ctx->width + 15) >> 4;
330  int mb_h = (ctx->height + 15) >> 4;
331  int grp_w = (mb_w + 4) / 5;
332  int grp_h = (mb_h + 4) / 5;
333  int grp_h_edge = grp_w * (mb_w / grp_w);
334  int grp_v_edge = grp_h * (mb_h / grp_h);
335  int grp_v_rest = mb_w - grp_h_edge;
336  int grp_h_rest = mb_h - grp_v_edge;
337  int num_mbs = mb_w * mb_h;
338  int num_tiles = (num_mbs + 479) / 480;
339  int std_tile_blocks = num_mbs / (16 * num_tiles);
340  int g_tile = slice_no * num_tiles;
341  int blk_addr, loc_addr, mb_x, mb_y, pos, loc_row, i;
342  int tile_blocks, tile_limit, tile_no;
343 
344  for (tile_no = 0; tile_no < num_tiles; tile_no++, g_tile++) {
345  tile_blocks = std_tile_blocks;
346  tile_limit = -1;
347  if (g_tile < num_mbs - std_tile_blocks * 16 * num_tiles) {
348  tile_limit = num_mbs / (16 * num_tiles);
349  tile_blocks++;
350  }
351  for (i = 0; i < tile_blocks; i++) {
352  if (i == tile_limit)
353  blk_addr = g_tile + 16 * num_tiles * i;
354  else
355  blk_addr = tile_no + 16 * num_tiles * i +
356  num_tiles * shuffle_16[(i + slice_no) & 0xF];
357  loc_row = grp_h * (blk_addr / (grp_h * mb_w));
358  loc_addr = blk_addr % (grp_h * mb_w);
359  if (loc_row >= grp_v_edge) {
360  mb_x = grp_w * (loc_addr / (grp_h_rest * grp_w));
361  pos = loc_addr % (grp_h_rest * grp_w);
362  } else {
363  mb_x = grp_w * (loc_addr / (grp_h * grp_w));
364  pos = loc_addr % (grp_h * grp_w);
365  }
366  if (mb_x >= grp_h_edge) {
367  mb_x += pos % grp_v_rest;
368  mb_y = loc_row + (pos / grp_v_rest);
369  } else {
370  mb_x += pos % grp_w;
371  mb_y = loc_row + (pos / grp_w);
372  }
373  ctx->decode_func(ctx, slice_no, mb_x * 16, mb_y * 16);
374  }
375  }
376 
377  return 0;
378 }
379 
380 static int decode_slice_thread(AVCodecContext *avctx, void *arg,
381  int slice_no, int threadnr)
382 {
383  HQXContext *ctx = avctx->priv_data;
384  uint32_t *slice_off = ctx->slice_off;
385  int ret;
386 
387  if (slice_off[slice_no] < HQX_HEADER_SIZE ||
388  slice_off[slice_no] >= slice_off[slice_no + 1] ||
389  slice_off[slice_no + 1] > ctx->data_size) {
390  av_log(avctx, AV_LOG_ERROR, "Invalid slice size %d.\n", ctx->data_size);
391  return AVERROR_INVALIDDATA;
392  }
393 
394  ret = init_get_bits8(&ctx->slice[slice_no].gb,
395  ctx->src + slice_off[slice_no],
396  slice_off[slice_no + 1] - slice_off[slice_no]);
397  if (ret < 0)
398  return ret;
399 
400  return decode_slice(ctx, slice_no);
401 }
402 
403 static int hqx_decode_frame(AVCodecContext *avctx, void *data,
404  int *got_picture_ptr, AVPacket *avpkt)
405 {
406  HQXContext *ctx = avctx->priv_data;
407  ThreadFrame frame = { .f = data };
408  uint8_t *src = avpkt->data;
409  uint32_t info_tag;
410  int data_start;
411  int i, ret;
412 
413  if (avpkt->size < 4 + 4) {
414  av_log(avctx, AV_LOG_ERROR, "Frame is too small %d.\n", avpkt->size);
415  return AVERROR_INVALIDDATA;
416  }
417 
418  info_tag = AV_RL32(src);
419  if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
420  uint32_t info_offset = AV_RL32(src + 4);
421  if (info_offset > INT_MAX || info_offset + 8 > avpkt->size) {
422  av_log(avctx, AV_LOG_ERROR,
423  "Invalid INFO header offset: 0x%08"PRIX32" is too large.\n",
424  info_offset);
425  return AVERROR_INVALIDDATA;
426  }
427  ff_canopus_parse_info_tag(avctx, src + 8, info_offset);
428 
429  info_offset += 8;
430  src += info_offset;
431  }
432 
433  data_start = src - avpkt->data;
434  ctx->data_size = avpkt->size - data_start;
435  ctx->src = src;
436  ctx->pic = data;
437 
438  if (ctx->data_size < HQX_HEADER_SIZE) {
439  av_log(avctx, AV_LOG_ERROR, "Frame too small.\n");
440  return AVERROR_INVALIDDATA;
441  }
442 
443  if (src[0] != 'H' || src[1] != 'Q') {
444  av_log(avctx, AV_LOG_ERROR, "Not an HQX frame.\n");
445  return AVERROR_INVALIDDATA;
446  }
447  ctx->interlaced = !(src[2] & 0x80);
448  ctx->format = src[2] & 7;
449  ctx->dcb = (src[3] & 3) + 8;
450  ctx->width = AV_RB16(src + 4);
451  ctx->height = AV_RB16(src + 6);
452  for (i = 0; i < 17; i++)
453  ctx->slice_off[i] = AV_RB24(src + 8 + i * 3);
454 
455  if (ctx->dcb == 8) {
456  av_log(avctx, AV_LOG_ERROR, "Invalid DC precision %d.\n", ctx->dcb);
457  return AVERROR_INVALIDDATA;
458  }
459  ret = av_image_check_size(ctx->width, ctx->height, 0, avctx);
460  if (ret < 0) {
461  av_log(avctx, AV_LOG_ERROR, "Invalid stored dimensions %dx%d.\n",
462  ctx->width, ctx->height);
463  return AVERROR_INVALIDDATA;
464  }
465 
466  avctx->coded_width = FFALIGN(ctx->width, 16);
467  avctx->coded_height = FFALIGN(ctx->height, 16);
468  avctx->width = ctx->width;
469  avctx->height = ctx->height;
470  avctx->bits_per_raw_sample = 10;
471 
472  //The minimum size is 2bit per macroblock
473  // hqx_decode_422 & hqx_decode_444 have a unconditionally stored 4bits hqx_quants index
474  // hqx_decode_422a & hqx_decode_444a use cbp_vlc which has a minimum length of 2 bits for its VLCs
475  // The code rejects slices overlapping in their input data
476  if (avctx->coded_width / 16 * (avctx->coded_height / 16) *
477  (100 - avctx->discard_damaged_percentage) / 100 > 4LL * avpkt->size)
478  return AVERROR_INVALIDDATA;
479 
480  switch (ctx->format) {
481  case HQX_422:
482  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
483  ctx->decode_func = hqx_decode_422;
484  break;
485  case HQX_444:
486  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
487  ctx->decode_func = hqx_decode_444;
488  break;
489  case HQX_422A:
491  ctx->decode_func = hqx_decode_422a;
492  break;
493  case HQX_444A:
495  ctx->decode_func = hqx_decode_444a;
496  break;
497  default:
498  av_log(avctx, AV_LOG_ERROR, "Invalid format: %d.\n", ctx->format);
499  return AVERROR_INVALIDDATA;
500  }
501 
502  ret = ff_thread_get_buffer(avctx, &frame, 0);
503  if (ret < 0)
504  return ret;
505 
506  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, 16);
507 
508  ctx->pic->key_frame = 1;
509  ctx->pic->pict_type = AV_PICTURE_TYPE_I;
510 
511  *got_picture_ptr = 1;
512 
513  return avpkt->size;
514 }
515 
517 {
518  int i;
519  HQXContext *ctx = avctx->priv_data;
520 
521  ff_free_vlc(&ctx->cbp_vlc);
522  for (i = 0; i < 3; i++) {
523  ff_free_vlc(&ctx->dc_vlc[i]);
524  }
525 
526  return 0;
527 }
528 
530 {
531  HQXContext *ctx = avctx->priv_data;
532 
533  ff_hqxdsp_init(&ctx->hqxdsp);
534 
535  return ff_hqx_init_vlcs(ctx);
536 }
537 
539  .name = "hqx",
540  .long_name = NULL_IF_CONFIG_SMALL("Canopus HQX"),
541  .type = AVMEDIA_TYPE_VIDEO,
542  .id = AV_CODEC_ID_HQX,
543  .priv_data_size = sizeof(HQXContext),
546  .close = hqx_decode_close,
547  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
549  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
551 };
static double val(void *priv, double ch)
Definition: aeval.c:76
#define av_cold
Definition: attributes.h:88
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> dc
uint8_t
Libavcodec external API header.
#define AV_RB24
Definition: intreadwrite.h:64
#define AV_RB16
Definition: intreadwrite.h:53
#define AV_RL32
Definition: intreadwrite.h:146
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:431
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
Definition: canopus.c:30
#define flag(name)
Definition: cbs_av1.c:553
static LevelCodes lev[4+3+3]
Definition: clearvideo.c:85
#define MKTAG(a, b, c, d)
Definition: common.h:478
#define NULL
Definition: coverity.c:32
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
bitstream reader API header.
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
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_HQX
Definition: codec_id.h:235
#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
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:317
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
static int decode_slice(HQXContext *ctx, int slice_no)
Definition: hqx.c:327
static const uint8_t hqx_quant_luma[64]
Definition: hqx.c:62
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int slice_no, int threadnr)
Definition: hqx.c:380
static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:274
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:84
static int hqx_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: hqx.c:403
AVCodec ff_hqx_decoder
Definition: hqx.c:538
static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:188
static const int shuffle_16[16]
Definition: hqx.c:323
static const int hqx_quants[16][4]
Definition: hqx.c:49
static int decode_block(GetBitContext *gb, VLC *vlc, const int *quants, int dcb, int16_t block[64], int *last_dc)
Definition: hqx.c:115
static void hqx_get_ac(GetBitContext *gb, const HQXAC *ac, int *run, int *lev)
Definition: hqx.c:99
static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:154
static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:238
HQXFormat
Definition: hqx.c:36
@ HQX_422A
Definition: hqx.c:39
@ HQX_422
Definition: hqx.c:37
@ HQX_444
Definition: hqx.c:38
@ HQX_444A
Definition: hqx.c:40
static av_cold int hqx_decode_close(AVCodecContext *avctx)
Definition: hqx.c:516
static const uint8_t hqx_quant_chroma[64]
Definition: hqx.c:73
#define HQX_HEADER_SIZE
Definition: hqx.c:43
static av_cold int hqx_decode_init(AVCodecContext *avctx)
Definition: hqx.c:529
int ff_hqx_init_vlcs(HQXContext *ctx)
Definition: hqxvlc.c:2151
const HQXAC ff_hqx_ac[NUM_HQX_AC]
Definition: hqxvlc.c:2132
@ HQX_AC_Q8
Definition: hqx.h:34
@ HQX_AC_Q16
Definition: hqx.h:35
@ HQX_AC_Q0
Definition: hqx.h:33
@ HQX_AC_Q64
Definition: hqx.h:37
@ HQX_AC_Q32
Definition: hqx.h:36
@ HQX_AC_Q128
Definition: hqx.h:38
#define HQX_CBP_VLC_BITS
Definition: hqx.h:81
#define HQX_DC_VLC_BITS
Definition: hqx.h:82
av_cold void ff_hqxdsp_init(HQXDSPContext *c)
Definition: hqxdsp.c:128
HQX DSP routines.
misc image utilities
int i
Definition: input.c:407
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
const char * arg
Definition: jacosubdec.c:66
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 FFALIGN(x, a)
Definition: macros.h:48
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
const char data[16]
Definition: mxf.c:142
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
unsigned int pos
Definition: spdifenc.c:412
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
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1747
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:2328
int coded_height
Definition: avcodec.h:724
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:1844
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 stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
Definition: hqx.h:48
int extra_bits
Definition: hqx.h:49
const HQXLUT * lut
Definition: hqx.h:50
int lut_bits
Definition: hqx.h:49
Definition: hqx.h:63
int8_t bits
Definition: hqx.h:45
uint8_t run
Definition: hqx.h:44
int16_t lev
Definition: hqx.h:43
Definition: hqx.h:58
GetBitContext gb
Definition: hqx.h:59
int16_t block[16][64]
Definition: hqx.h:60
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
uint8_t run
Definition: svq3.c:205
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static int16_t block[64]
Definition: dct.c:116
static int16_t block1[64]
Definition: dct.c:117
AVFormatContext * ctx
Definition: movenc.c:48
if(ret< 0)
Definition: vf_mcdeint.c:282
const uint8_t * quant