FFmpeg: libavcodec/hqx.c Source File

FFmpeg
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,
38   HQX_444,
39   HQX_422A,
40   HQX_444A,
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  if (dc < 0)
126  return AVERROR_INVALIDDATA;
127  *last_dc += dc;
128 
129  block[0] = sign_extend(*last_dc << (12 - dcb), 12);
130 
131  q = quants[get_bits(gb, 2)];
132  if (q >= 128)
133  ac_idx = HQX_AC_Q128;
134  else if (q >= 64)
135  ac_idx = HQX_AC_Q64;
136  else if (q >= 32)
137  ac_idx = HQX_AC_Q32;
138  else if (q >= 16)
139  ac_idx = HQX_AC_Q16;
140  else if (q >= 8)
141  ac_idx = HQX_AC_Q8;
142  else
143  ac_idx = HQX_AC_Q0;
144 
145  do {
146  hqx_get_ac(gb, &ff_hqx_ac[ac_idx], &run, &lev);
147  pos += run;
148  if (pos >= 64)
149  break;
150  block[ff_zigzag_direct[pos++]] = lev * q;
151  } while (pos < 64);
152 
153  return 0;
154 }
155 
156  static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
157 {
158  HQXSlice *slice = &ctx->slice[slice_no];
159  GetBitContext *gb = &slice->gb;
160  const int *quants;
161  int flag;
162  int last_dc;
163  int i, ret;
164 
165  if (ctx->interlaced)
166  flag = get_bits1(gb);
167  else
168  flag = 0;
169 
170  quants = hqx_quants[get_bits(gb, 4)];
171 
172  for (i = 0; i < 8; i++) {
173  int vlc_index = ctx->dcb - 9;
174  if (i == 0 || i == 4 || i == 6)
175  last_dc = 0;
176  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
177  ctx->dcb, slice->block[i], &last_dc);
178  if (ret < 0)
179  return ret;
180  }
181 
182  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[2], hqx_quant_luma);
183  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[3], hqx_quant_luma);
184  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[4], slice->block[5], hqx_quant_chroma);
185  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[6], slice->block[7], hqx_quant_chroma);
186 
187  return 0;
188 }
189 
190  static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
191 {
192  HQXSlice *slice = &ctx->slice[slice_no];
193  GetBitContext *gb = &slice->gb;
194  const int *quants;
195  int flag = 0;
196  int last_dc;
197  int i, ret;
198  int cbp;
199 
200  cbp = get_vlc2(gb, ctx->cbp_vlc.table, ctx->cbp_vlc.bits, 1);
201 
202  for (i = 0; i < 12; i++)
203  memset(slice->block[i], 0, sizeof(**slice->block) * 64);
204  for (i = 0; i < 12; i++)
205  slice->block[i][0] = -0x800;
206  if (cbp) {
207  if (ctx->interlaced)
208  flag = get_bits1(gb);
209 
210  quants = hqx_quants[get_bits(gb, 4)];
211 
212  cbp |= cbp << 4; // alpha CBP
213  if (cbp & 0x3) // chroma CBP - top
214  cbp |= 0x500;
215  if (cbp & 0xC) // chroma CBP - bottom
216  cbp |= 0xA00;
217  for (i = 0; i < 12; i++) {
218  if (i == 0 || i == 4 || i == 8 || i == 10)
219  last_dc = 0;
220  if (cbp & (1 << i)) {
221  int vlc_index = ctx->dcb - 9;
222  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
223  ctx->dcb, slice->block[i], &last_dc);
224  if (ret < 0)
225  return ret;
226  }
227  }
228  }
229 
230  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
231  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
232  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
233  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
234  put_blocks(ctx, 2, x >> 1, y, flag, slice->block[ 8], slice->block[ 9], hqx_quant_chroma);
235  put_blocks(ctx, 1, x >> 1, y, flag, slice->block[10], slice->block[11], hqx_quant_chroma);
236 
237  return 0;
238 }
239 
240  static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
241 {
242  HQXSlice *slice = &ctx->slice[slice_no];
243  GetBitContext *gb = &slice->gb;
244  const int *quants;
245  int flag;
246  int last_dc;
247  int i, ret;
248 
249  if (ctx->interlaced)
250  flag = get_bits1(gb);
251  else
252  flag = 0;
253 
254  quants = hqx_quants[get_bits(gb, 4)];
255 
256  for (i = 0; i < 12; i++) {
257  int vlc_index = ctx->dcb - 9;
258  if (i == 0 || i == 4 || i == 8)
259  last_dc = 0;
260  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
261  ctx->dcb, slice->block[i], &last_dc);
262  if (ret < 0)
263  return ret;
264  }
265 
266  put_blocks(ctx, 0, x, y, flag, slice->block[0], slice->block[ 2], hqx_quant_luma);
267  put_blocks(ctx, 0, x + 8, y, flag, slice->block[1], slice->block[ 3], hqx_quant_luma);
268  put_blocks(ctx, 2, x, y, flag, slice->block[4], slice->block[ 6], hqx_quant_chroma);
269  put_blocks(ctx, 2, x + 8, y, flag, slice->block[5], slice->block[ 7], hqx_quant_chroma);
270  put_blocks(ctx, 1, x, y, flag, slice->block[8], slice->block[10], hqx_quant_chroma);
271  put_blocks(ctx, 1, x + 8, y, flag, slice->block[9], slice->block[11], hqx_quant_chroma);
272 
273  return 0;
274 }
275 
276  static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
277 {
278  HQXSlice *slice = &ctx->slice[slice_no];
279  GetBitContext *gb = &slice->gb;
280  const int *quants;
281  int flag = 0;
282  int last_dc;
283  int i, ret;
284  int cbp;
285 
286  cbp = get_vlc2(gb, ctx->cbp_vlc.table, ctx->cbp_vlc.bits, 1);
287 
288  for (i = 0; i < 16; i++)
289  memset(slice->block[i], 0, sizeof(**slice->block) * 64);
290  for (i = 0; i < 16; i++)
291  slice->block[i][0] = -0x800;
292  if (cbp) {
293  if (ctx->interlaced)
294  flag = get_bits1(gb);
295 
296  quants = hqx_quants[get_bits(gb, 4)];
297 
298  cbp |= cbp << 4; // alpha CBP
299  cbp |= cbp << 8; // chroma CBP
300  for (i = 0; i < 16; i++) {
301  if (i == 0 || i == 4 || i == 8 || i == 12)
302  last_dc = 0;
303  if (cbp & (1 << i)) {
304  int vlc_index = ctx->dcb - 9;
305  ret = decode_block(gb, &ctx->dc_vlc[vlc_index], quants,
306  ctx->dcb, slice->block[i], &last_dc);
307  if (ret < 0)
308  return ret;
309  }
310  }
311  }
312 
313  put_blocks(ctx, 3, x, y, flag, slice->block[ 0], slice->block[ 2], hqx_quant_luma);
314  put_blocks(ctx, 3, x + 8, y, flag, slice->block[ 1], slice->block[ 3], hqx_quant_luma);
315  put_blocks(ctx, 0, x, y, flag, slice->block[ 4], slice->block[ 6], hqx_quant_luma);
316  put_blocks(ctx, 0, x + 8, y, flag, slice->block[ 5], slice->block[ 7], hqx_quant_luma);
317  put_blocks(ctx, 2, x, y, flag, slice->block[ 8], slice->block[10], hqx_quant_chroma);
318  put_blocks(ctx, 2, x + 8, y, flag, slice->block[ 9], slice->block[11], hqx_quant_chroma);
319  put_blocks(ctx, 1, x, y, flag, slice->block[12], slice->block[14], hqx_quant_chroma);
320  put_blocks(ctx, 1, x + 8, y, flag, slice->block[13], slice->block[15], hqx_quant_chroma);
321 
322  return 0;
323 }
324 
325  static const int shuffle_16[16] = {
326  0, 5, 11, 14, 2, 7, 9, 13, 1, 4, 10, 15, 3, 6, 8, 12
327 };
328 
329  static int decode_slice(HQXContext *ctx, int slice_no)
330 {
331  int mb_w = (ctx->width + 15) >> 4;
332  int mb_h = (ctx->height + 15) >> 4;
333  int grp_w = (mb_w + 4) / 5;
334  int grp_h = (mb_h + 4) / 5;
335  int grp_h_edge = grp_w * (mb_w / grp_w);
336  int grp_v_edge = grp_h * (mb_h / grp_h);
337  int grp_v_rest = mb_w - grp_h_edge;
338  int grp_h_rest = mb_h - grp_v_edge;
339  int num_mbs = mb_w * mb_h;
340  int num_tiles = (num_mbs + 479) / 480;
341  int std_tile_blocks = num_mbs / (16 * num_tiles);
342  int g_tile = slice_no * num_tiles;
343  int blk_addr, loc_addr, mb_x, mb_y, pos, loc_row, i;
344  int tile_blocks, tile_limit, tile_no;
345 
346  for (tile_no = 0; tile_no < num_tiles; tile_no++, g_tile++) {
347  tile_blocks = std_tile_blocks;
348  tile_limit = -1;
349  if (g_tile < num_mbs - std_tile_blocks * 16 * num_tiles) {
350  tile_limit = num_mbs / (16 * num_tiles);
351  tile_blocks++;
352  }
353  for (i = 0; i < tile_blocks; i++) {
354  if (i == tile_limit)
355  blk_addr = g_tile + 16 * num_tiles * i;
356  else
357  blk_addr = tile_no + 16 * num_tiles * i +
358  num_tiles * shuffle_16[(i + slice_no) & 0xF];
359  loc_row = grp_h * (blk_addr / (grp_h * mb_w));
360  loc_addr = blk_addr % (grp_h * mb_w);
361  if (loc_row >= grp_v_edge) {
362  mb_x = grp_w * (loc_addr / (grp_h_rest * grp_w));
363  pos = loc_addr % (grp_h_rest * grp_w);
364  } else {
365  mb_x = grp_w * (loc_addr / (grp_h * grp_w));
366  pos = loc_addr % (grp_h * grp_w);
367  }
368  if (mb_x >= grp_h_edge) {
369  mb_x += pos % grp_v_rest;
370  mb_y = loc_row + (pos / grp_v_rest);
371  } else {
372  mb_x += pos % grp_w;
373  mb_y = loc_row + (pos / grp_w);
374  }
375  ctx->decode_func(ctx, slice_no, mb_x * 16, mb_y * 16);
376  }
377  }
378 
379  return 0;
380 }
381 
382  static int decode_slice_thread(AVCodecContext *avctx, void *arg,
383  int slice_no, int threadnr)
384 {
385  HQXContext *ctx = avctx->priv_data;
386  uint32_t *slice_off = ctx->slice_off;
387  int ret;
388 
389  if (slice_off[slice_no] < HQX_HEADER_SIZE ||
390  slice_off[slice_no] >= slice_off[slice_no + 1] ||
391  slice_off[slice_no + 1] > ctx->data_size) {
392  av_log(avctx, AV_LOG_ERROR, "Invalid slice size %d.\n", ctx->data_size);
393  return AVERROR_INVALIDDATA;
394  }
395 
396  ret = init_get_bits8(&ctx->slice[slice_no].gb,
397  ctx->src + slice_off[slice_no],
398  slice_off[slice_no + 1] - slice_off[slice_no]);
399  if (ret < 0)
400  return ret;
401 
402  return decode_slice(ctx, slice_no);
403 }
404 
405  static int hqx_decode_frame(AVCodecContext *avctx, void *data,
406  int *got_picture_ptr, AVPacket *avpkt)
407 {
408  HQXContext *ctx = avctx->priv_data;
409  ThreadFrame frame = { .f = data };
410  uint8_t *src = avpkt->data;
411  uint32_t info_tag;
412  int data_start;
413  int i, ret;
414 
415  if (avpkt->size < 4 + 4) {
416  av_log(avctx, AV_LOG_ERROR, "Frame is too small %d.\n", avpkt->size);
417  return AVERROR_INVALIDDATA;
418  }
419 
420  info_tag = AV_RL32(src);
421  if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
422  uint32_t info_offset = AV_RL32(src + 4);
423  if (info_offset > INT_MAX || info_offset + 8 > avpkt->size) {
424  av_log(avctx, AV_LOG_ERROR,
425  "Invalid INFO header offset: 0x%08"PRIX32" is too large.\n",
426  info_offset);
427  return AVERROR_INVALIDDATA;
428  }
429  ff_canopus_parse_info_tag(avctx, src + 8, info_offset);
430 
431  info_offset += 8;
432  src += info_offset;
433  }
434 
435  data_start = src - avpkt->data;
436  ctx->data_size = avpkt->size - data_start;
437  ctx->src = src;
438  ctx->pic = data;
439 
440  if (ctx->data_size < HQX_HEADER_SIZE) {
441  av_log(avctx, AV_LOG_ERROR, "Frame too small.\n");
442  return AVERROR_INVALIDDATA;
443  }
444 
445  if (src[0] != 'H' || src[1] != 'Q') {
446  av_log(avctx, AV_LOG_ERROR, "Not an HQX frame.\n");
447  return AVERROR_INVALIDDATA;
448  }
449  ctx->interlaced = !(src[2] & 0x80);
450  ctx->format = src[2] & 7;
451  ctx->dcb = (src[3] & 3) + 8;
452  ctx->width = AV_RB16(src + 4);
453  ctx->height = AV_RB16(src + 6);
454  for (i = 0; i < 17; i++)
455  ctx->slice_off[i] = AV_RB24(src + 8 + i * 3);
456 
457  if (ctx->dcb == 8) {
458  av_log(avctx, AV_LOG_ERROR, "Invalid DC precision %d.\n", ctx->dcb);
459  return AVERROR_INVALIDDATA;
460  }
461  ret = av_image_check_size(ctx->width, ctx->height, 0, avctx);
462  if (ret < 0) {
463  av_log(avctx, AV_LOG_ERROR, "Invalid stored dimensions %dx%d.\n",
464  ctx->width, ctx->height);
465  return AVERROR_INVALIDDATA;
466  }
467 
468  avctx->coded_width = FFALIGN(ctx->width, 16);
469  avctx->coded_height = FFALIGN(ctx->height, 16);
470  avctx->width = ctx->width;
471  avctx->height = ctx->height;
472  avctx->bits_per_raw_sample = 10;
473 
474  switch (ctx->format) {
475  case HQX_422:
476  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
477  ctx->decode_func = hqx_decode_422;
478  break;
479  case HQX_444:
480  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
481  ctx->decode_func = hqx_decode_444;
482  break;
483  case HQX_422A:
484  avctx->pix_fmt = AV_PIX_FMT_YUVA422P16;
485  ctx->decode_func = hqx_decode_422a;
486  break;
487  case HQX_444A:
488  avctx->pix_fmt = AV_PIX_FMT_YUVA444P16;
489  ctx->decode_func = hqx_decode_444a;
490  break;
491  default:
492  av_log(avctx, AV_LOG_ERROR, "Invalid format: %d.\n", ctx->format);
493  return AVERROR_INVALIDDATA;
494  }
495 
496  ret = ff_thread_get_buffer(avctx, &frame, 0);
497  if (ret < 0)
498  return ret;
499 
500  avctx->execute2(avctx, decode_slice_thread, NULL, NULL, 16);
501 
502  ctx->pic->key_frame = 1;
503  ctx->pic->pict_type = AV_PICTURE_TYPE_I;
504 
505  *got_picture_ptr = 1;
506 
507  return avpkt->size;
508 }
509 
510  static av_cold int hqx_decode_close(AVCodecContext *avctx)
511 {
512  int i;
513  HQXContext *ctx = avctx->priv_data;
514 
515  if (avctx->internal->is_copy)
516  return 0;
517 
518  ff_free_vlc(&ctx->cbp_vlc);
519  for (i = 0; i < 3; i++) {
520  ff_free_vlc(&ctx->dc_vlc[i]);
521  }
522 
523  return 0;
524 }
525 
526  static av_cold int hqx_decode_init(AVCodecContext *avctx)
527 {
528  HQXContext *ctx = avctx->priv_data;
529 
530  ff_hqxdsp_init(&ctx->hqxdsp);
531 
532  return ff_hqx_init_vlcs(ctx);
533 }
534 
535  AVCodec ff_hqx_decoder = {
536  .name = "hqx",
537  .long_name = NULL_IF_CONFIG_SMALL("Canopus HQX"),
538  .type = AVMEDIA_TYPE_VIDEO,
539  .id = AV_CODEC_ID_HQX,
540  .priv_data_size = sizeof(HQXContext),
541  .init = hqx_decode_init,
542  .decode = hqx_decode_frame,
543  .close = hqx_decode_close,
544  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
545  AV_CODEC_CAP_FRAME_THREADS,
546  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
547  FF_CODEC_CAP_INIT_CLEANUP,
548 };
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: internal.h:48
plane
int plane
Definition: avisynth_c.h:422
HQXAC
Definition: hqx.h:47
NULL
#define NULL
Definition: coverity.c:32
AV_CODEC_ID_HQX
Definition: avcodec.h:404
val
const char const char void * val
Definition: avisynth_c.h:771
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:407
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
HQXContext::dcb
int dcb
Definition: hqx.h:69
HQXContext::slice
HQXSlice slice[16]
Definition: hqx.h:64
HQXContext::height
int height
Definition: hqx.h:69
flag
#define flag(name)
Definition: cbs_h2645.c:346
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
HQXContext::interlaced
int interlaced
Definition: hqx.h:70
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1705
imgutils.h
misc image utilities
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
hqx_get_ac
static void hqx_get_ac(GetBitContext *gb, const HQXAC *ac, int *run, int *lev)
Definition: hqx.c:99
HQX_DC_VLC_BITS
#define HQX_DC_VLC_BITS
Definition: hqx.h:80
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
ff_canopus_parse_info_tag
int ff_canopus_parse_info_tag(AVCodecContext *avctx, const uint8_t *src, size_t size)
Definition: canopus.c:30
HQX_422A
Definition: hqx.c:39
HQXSlice::gb
GetBitContext gb
Definition: hqx.h:58
AVPacket::size
int size
Definition: avcodec.h:1431
HQX_AC_Q32
Definition: hqx.h:35
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
HQXContext::decode_func
mb_decode_func decode_func
Definition: hqx.h:67
ff_hqx_init_vlcs
int ff_hqx_init_vlcs(HQXContext *ctx)
Definition: hqxvlc.c:2151
HQXDSPContext::idct_put
void(* idct_put)(uint16_t *dst, ptrdiff_t stride, int16_t *block, const uint8_t *quant)
Definition: hqxdsp.h:33
run
uint8_t run
Definition: svq3.c:206
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2741
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:87
src
#define src
Definition: vp8dsp.c:254
AVCodec
AVCodec.
Definition: avcodec.h:3408
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
HQX_AC_Q16
Definition: hqx.h:34
hqx_decode_init
static av_cold int hqx_decode_init(AVCodecContext *avctx)
Definition: hqx.c:526
hqx_decode_frame
static int hqx_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
Definition: hqx.c:405
block
static int16_t block[64]
Definition: dct.c:115
ff_hqx_ac
const HQXAC ff_hqx_ac[NUM_HQX_AC]
Definition: hqxvlc.c:2132
HQXContext::src
uint8_t * src
Definition: hqx.h:72
FF_CODEC_CAP_INIT_THREADSAFE
#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:40
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:82
HQXLUT::run
uint8_t run
Definition: hqx.h:43
thread.h
Multithreading support functions.
hqx_decode_422a
static int hqx_decode_422a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:190
hqx_quant_luma
static const uint8_t hqx_quant_luma[64]
Definition: hqx.c:62
frame
static AVFrame * frame
Definition: demuxing_decoding.c:53
hqx_quants
static const int hqx_quants[16][4]
Definition: hqx.c:49
AVPacket::data
uint8_t * data
Definition: avcodec.h:1430
get_bits.h
bitstream reader API header.
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:381
hqx_quant_chroma
static const uint8_t hqx_quant_chroma[64]
Definition: hqx.c:73
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_hqx_decoder
AVCodec ff_hqx_decoder
Definition: hqx.c:535
HQXAC::lut
const HQXLUT * lut
Definition: hqx.h:49
hqx_decode_422
static int hqx_decode_422(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:156
HQXContext::dc_vlc
VLC dc_vlc[3]
Definition: hqx.h:77
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
hqx_decode_close
static av_cold int hqx_decode_close(AVCodecContext *avctx)
Definition: hqx.c:510
AVCodecInternal::is_copy
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:136
decode_slice
static int decode_slice(HQXContext *ctx, int slice_no)
Definition: hqx.c:329
HQXAC::lut_bits
int lut_bits
Definition: hqx.h:48
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
decode_block
static int decode_block(GetBitContext *gb, VLC *vlc, const int *quants, int dcb, int16_t block[64], int *last_dc)
Definition: hqx.c:115
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:408
arg
const char * arg
Definition: jacosubdec.c:66
HQX_444
Definition: hqx.c:38
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1015
HQXContext
Definition: hqx.h:62
VLC
Definition: vlc.h:26
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:282
HQXSlice
Definition: hqx.h:57
HQX_AC_Q64
Definition: hqx.h:36
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1690
ctx
AVFormatContext * ctx
Definition: movenc.c:48
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:304
HQXAC::extra_bits
int extra_bits
Definition: hqx.h:48
get_vlc2
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:563
hqxdsp.h
HQX DSP routines.
HQX_444A
Definition: hqx.c:40
HQX_HEADER_SIZE
#define HQX_HEADER_SIZE
Definition: hqx.c:43
AVCodecContext::height
int height
Definition: avcodec.h:1690
VLC::bits
int bits
Definition: vlc.h:27
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1019
HQXContext::width
int width
Definition: hqx.h:69
hqx_decode_444a
static int hqx_decode_444a(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:276
HQX_AC_Q0
Definition: hqx.h:32
decode_slice_thread
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int slice_no, int threadnr)
Definition: hqx.c:382
avcodec.h
Libavcodec external API header.
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:87
HQXLUT::bits
int8_t bits
Definition: hqx.h:44
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:464
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:965
AVCodecContext
main external API structure.
Definition: avcodec.h:1518
HQXFormat
HQXFormat
Definition: hqx.c:36
HQXSlice::block
int16_t block[16][64]
Definition: hqx.h:59
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:321
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:1705
shuffle_16
static const int shuffle_16[16]
Definition: hqx.c:325
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:314
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
quant
const uint8_t * quant
Definition: vorbis_enc_data.h:458
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
HQXContext::slice_off
uint32_t slice_off[17]
Definition: hqx.h:74
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
HQXLUT::lev
int16_t lev
Definition: hqx.h:42
HQX_422
Definition: hqx.c:37
internal.h
common internal api header.
if
if(ret< 0)
Definition: vf_mcdeint.c:279
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:84
HQXContext::data_size
unsigned int data_size
Definition: hqx.h:73
ff_hqxdsp_init
av_cold void ff_hqxdsp_init(HQXDSPContext *c)
Definition: hqxdsp.c:128
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1545
HQXContext::pic
AVFrame * pic
Definition: hqx.h:66
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:2829
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1553
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
HQXContext::format
int format
Definition: hqx.h:69
HQXContext::cbp_vlc
VLC cbp_vlc
Definition: hqx.h:76
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
block1
static int16_t block1[64]
Definition: dct.c:116
dc
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
Definition: audio_convert.c:194
HQX_AC_Q8
Definition: hqx.h:33
HQX_AC_Q128
Definition: hqx.h:37
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
hqx_decode_444
static int hqx_decode_444(HQXContext *ctx, int slice_no, int x, int y)
Definition: hqx.c:240
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:366
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1407
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:354
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:380
HQXContext::hqxdsp
HQXDSPContext hqxdsp
Definition: hqx.h:63
Generated on Sun May 13 2018 02:03:48 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /