FFmpeg  2.8.17
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
aic.c
Go to the documentation of this file.
1 /*
2  * Apple Intermediate Codec decoder
3  *
4  * Copyright (c) 2013 Konstantin Shishkov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <inttypes.h>
24 
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "internal.h"
28 #include "get_bits.h"
29 #include "golomb.h"
30 #include "idctdsp.h"
31 #include "unary.h"
32 
33 #define AIC_HDR_SIZE 24
34 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
35 
36 enum AICBands {
42 };
43 
44 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
45 
46 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
47 
48 static const uint8_t aic_quant_matrix[64] = {
49  8, 16, 19, 22, 22, 26, 26, 27,
50  16, 16, 22, 22, 26, 27, 27, 29,
51  19, 22, 26, 26, 27, 29, 29, 35,
52  22, 24, 27, 27, 29, 32, 34, 38,
53  26, 27, 29, 29, 32, 35, 38, 46,
54  27, 29, 34, 34, 35, 40, 46, 56,
55  29, 34, 34, 37, 40, 48, 56, 69,
56  34, 37, 38, 40, 48, 58, 69, 83,
57 };
58 
59 static const uint8_t aic_y_scan[64] = {
60  0, 4, 1, 2, 5, 8, 12, 9,
61  6, 3, 7, 10, 13, 14, 11, 15,
62  47, 43, 46, 45, 42, 39, 35, 38,
63  41, 44, 40, 37, 34, 33, 36, 32,
64  16, 20, 17, 18, 21, 24, 28, 25,
65  22, 19, 23, 26, 29, 30, 27, 31,
66  63, 59, 62, 61, 58, 55, 51, 54,
67  57, 60, 56, 53, 50, 49, 52, 48,
68 };
69 
70 static const uint8_t aic_y_ext_scan[192] = {
71  64, 72, 65, 66, 73, 80, 88, 81,
72  74, 67, 75, 82, 89, 90, 83, 91,
73  0, 4, 1, 2, 5, 8, 12, 9,
74  6, 3, 7, 10, 13, 14, 11, 15,
75  16, 20, 17, 18, 21, 24, 28, 25,
76  22, 19, 23, 26, 29, 30, 27, 31,
77  155, 147, 154, 153, 146, 139, 131, 138,
78  145, 152, 144, 137, 130, 129, 136, 128,
79  47, 43, 46, 45, 42, 39, 35, 38,
80  41, 44, 40, 37, 34, 33, 36, 32,
81  63, 59, 62, 61, 58, 55, 51, 54,
82  57, 60, 56, 53, 50, 49, 52, 48,
83  96, 104, 97, 98, 105, 112, 120, 113,
84  106, 99, 107, 114, 121, 122, 115, 123,
85  68, 76, 69, 70, 77, 84, 92, 85,
86  78, 71, 79, 86, 93, 94, 87, 95,
87  100, 108, 101, 102, 109, 116, 124, 117,
88  110, 103, 111, 118, 125, 126, 119, 127,
89  187, 179, 186, 185, 178, 171, 163, 170,
90  177, 184, 176, 169, 162, 161, 168, 160,
91  159, 151, 158, 157, 150, 143, 135, 142,
92  149, 156, 148, 141, 134, 133, 140, 132,
93  191, 183, 190, 189, 182, 175, 167, 174,
94  181, 188, 180, 173, 166, 165, 172, 164,
95 };
96 
97 static const uint8_t aic_c_scan[64] = {
98  0, 4, 1, 2, 5, 8, 12, 9,
99  6, 3, 7, 10, 13, 14, 11, 15,
100  31, 27, 30, 29, 26, 23, 19, 22,
101  25, 28, 24, 21, 18, 17, 20, 16,
102  32, 36, 33, 34, 37, 40, 44, 41,
103  38, 35, 39, 42, 45, 46, 43, 47,
104  63, 59, 62, 61, 58, 55, 51, 54,
105  57, 60, 56, 53, 50, 49, 52, 48,
106 };
107 
108 static const uint8_t aic_c_ext_scan[192] = {
109  16, 24, 17, 18, 25, 32, 40, 33,
110  26, 19, 27, 34, 41, 42, 35, 43,
111  0, 4, 1, 2, 5, 8, 12, 9,
112  6, 3, 7, 10, 13, 14, 11, 15,
113  20, 28, 21, 22, 29, 36, 44, 37,
114  30, 23, 31, 38, 45, 46, 39, 47,
115  95, 87, 94, 93, 86, 79, 71, 78,
116  85, 92, 84, 77, 70, 69, 76, 68,
117  63, 59, 62, 61, 58, 55, 51, 54,
118  57, 60, 56, 53, 50, 49, 52, 48,
119  91, 83, 90, 89, 82, 75, 67, 74,
120  81, 88, 80, 73, 66, 65, 72, 64,
121  112, 120, 113, 114, 121, 128, 136, 129,
122  122, 115, 123, 130, 137, 138, 131, 139,
123  96, 100, 97, 98, 101, 104, 108, 105,
124  102, 99, 103, 106, 109, 110, 107, 111,
125  116, 124, 117, 118, 125, 132, 140, 133,
126  126, 119, 127, 134, 141, 142, 135, 143,
127  191, 183, 190, 189, 182, 175, 167, 174,
128  181, 188, 180, 173, 166, 165, 172, 164,
129  159, 155, 158, 157, 154, 151, 147, 150,
130  153, 156, 152, 149, 146, 145, 148, 144,
131  187, 179, 186, 185, 178, 171, 163, 170,
132  177, 184, 176, 169, 162, 161, 168, 160,
133 };
134 
135 static const uint8_t * const aic_scan[NUM_BANDS] = {
137 };
138 
139 typedef struct AICContext {
144 
148  int quant;
150 
151  int16_t *slice_data;
152  int16_t *data_ptr[NUM_BANDS];
153 
154  DECLARE_ALIGNED(16, int16_t, block)[64];
156 } AICContext;
157 
158 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
159 {
160  uint32_t frame_size;
161  int width, height;
162 
163  if (src[0] != 1) {
164  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
165  return AVERROR_INVALIDDATA;
166  }
167  if (src[1] != AIC_HDR_SIZE - 2) {
168  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
169  return AVERROR_INVALIDDATA;
170  }
171  frame_size = AV_RB32(src + 2);
172  width = AV_RB16(src + 6);
173  height = AV_RB16(src + 8);
174  if (frame_size > size) {
175  av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
176  frame_size, size);
177  return AVERROR_INVALIDDATA;
178  }
179  if (width != ctx->avctx->width || height != ctx->avctx->height) {
180  av_log(ctx->avctx, AV_LOG_ERROR,
181  "Picture dimension changed: old: %d x %d, new: %d x %d\n",
182  ctx->avctx->width, ctx->avctx->height, width, height);
183  return AVERROR_INVALIDDATA;
184  }
185  ctx->quant = src[15];
186  ctx->interlaced = ((src[16] >> 4) == 3);
187 
188  return 0;
189 }
190 
191 #define GET_CODE(val, type, add_bits) \
192  do { \
193  if (type) \
194  val = get_ue_golomb(gb); \
195  else \
196  val = get_unary(gb, 1, 31); \
197  if (add_bits) \
198  val = (val << add_bits) + get_bits(gb, add_bits); \
199  } while (0)
200 
201 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
202  int band, int slice_width, int force_chroma)
203 {
204  int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
205  const int num_coeffs = aic_num_band_coeffs[band];
206  const uint8_t *scan = aic_scan[band | force_chroma];
207  int mb, idx;
208  unsigned val;
209 
210  if (get_bits_left(gb) < 5)
211  return AVERROR_INVALIDDATA;
212 
213  has_skips = get_bits1(gb);
214  coeff_type = get_bits1(gb);
215  coeff_bits = get_bits(gb, 3);
216 
217  if (has_skips) {
218  skip_type = get_bits1(gb);
219  skip_bits = get_bits(gb, 3);
220 
221  for (mb = 0; mb < slice_width; mb++) {
222  idx = -1;
223  do {
224  GET_CODE(val, skip_type, skip_bits);
225  if (val >= 0x10000)
226  return AVERROR_INVALIDDATA;
227  idx += val + 1;
228  if (idx >= num_coeffs)
229  break;
230  GET_CODE(val, coeff_type, coeff_bits);
231  val++;
232  if (val >= 0x10000)
233  return AVERROR_INVALIDDATA;
234  dst[scan[idx]] = val;
235  } while (idx < num_coeffs - 1);
236  dst += num_coeffs;
237  }
238  } else {
239  for (mb = 0; mb < slice_width; mb++) {
240  for (idx = 0; idx < num_coeffs; idx++) {
241  GET_CODE(val, coeff_type, coeff_bits);
242  if (val >= 0x10000)
243  return AVERROR_INVALIDDATA;
244  dst[scan[idx]] = val;
245  }
246  dst += num_coeffs;
247  }
248  }
249  return 0;
250 }
251 
252 static void recombine_block(int16_t *dst, const uint8_t *scan,
253  int16_t **base, int16_t **ext)
254 {
255  int i, j;
256 
257  for (i = 0; i < 4; i++) {
258  for (j = 0; j < 4; j++)
259  dst[scan[i * 8 + j]] = (*base)[j];
260  for (j = 0; j < 4; j++)
261  dst[scan[i * 8 + j + 4]] = (*ext)[j];
262  *base += 4;
263  *ext += 4;
264  }
265  for (; i < 8; i++) {
266  for (j = 0; j < 8; j++)
267  dst[scan[i * 8 + j]] = (*ext)[j];
268  *ext += 8;
269  }
270 }
271 
272 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
273  int16_t **base, int16_t **ext,
274  int block_no)
275 {
276  int i, j;
277 
278  if (block_no < 2) {
279  for (i = 0; i < 8; i++) {
280  for (j = 0; j < 4; j++)
281  dst[scan[i * 8 + j]] = (*base)[j];
282  for (j = 0; j < 4; j++)
283  dst[scan[i * 8 + j + 4]] = (*ext)[j];
284  *base += 4;
285  *ext += 4;
286  }
287  } else {
288  for (i = 0; i < 64; i++)
289  dst[scan[i]] = (*ext)[i];
290  *ext += 64;
291  }
292 }
293 
294 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
295 {
296  int i;
297 
298  for (i = 0; i < 64; i++) {
299  int val = (uint16_t)block[i];
300  int sign = val & 1;
301 
302  block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
303  + sign;
304  }
305 }
306 
307 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
308  const uint8_t *src, int src_size)
309 {
310  GetBitContext gb;
311  int ret, i, mb, blk;
312  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
313  uint8_t *Y, *C[2];
314  uint8_t *dst;
315  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
316  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
317  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
318  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
319  const int ystride = ctx->frame->linesize[0];
320 
321  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
322  for (i = 0; i < 2; i++)
323  C[i] = ctx->frame->data[i + 1] + mb_x * 8
324  + mb_y * 8 * ctx->frame->linesize[i + 1];
325  init_get_bits(&gb, src, src_size * 8);
326 
327  memset(ctx->slice_data, 0,
328  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
329  for (i = 0; i < NUM_BANDS; i++)
330  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
331  i, slice_width,
332  !ctx->interlaced)) < 0)
333  return ret;
334 
335  for (mb = 0; mb < slice_width; mb++) {
336  for (blk = 0; blk < 4; blk++) {
337  if (!ctx->interlaced)
339  &base_y, &ext_y);
340  else
342  &base_y, &ext_y, blk);
343  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
344  ctx->idsp.idct(ctx->block);
345 
346  if (!ctx->interlaced) {
347  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
348  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
349  } else {
350  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
351  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
352  ystride * 2);
353  }
354  }
355  Y += 16;
356 
357  for (blk = 0; blk < 2; blk++) {
359  &base_c, &ext_c);
360  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
361  ctx->idsp.idct(ctx->block);
362  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
363  ctx->frame->linesize[blk + 1]);
364  C[blk] += 8;
365  }
366  }
367 
368  return 0;
369 }
370 
371 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
372  AVPacket *avpkt)
373 {
374  AICContext *ctx = avctx->priv_data;
375  const uint8_t *buf = avpkt->data;
376  int buf_size = avpkt->size;
377  GetByteContext gb;
378  uint32_t off;
379  int x, y, ret;
380  int slice_size;
381 
382  ctx->frame = data;
384  ctx->frame->key_frame = 1;
385 
386  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
387 
388  if (buf_size < off) {
389  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
390  return AVERROR_INVALIDDATA;
391  }
392 
393  ret = aic_decode_header(ctx, buf, buf_size);
394  if (ret < 0) {
395  av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
396  return ret;
397  }
398 
399  if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
400  return ret;
401 
402  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
403  ctx->num_x_slices * ctx->mb_height * 2);
404 
405  for (y = 0; y < ctx->mb_height; y++) {
406  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
407  slice_size = bytestream2_get_le16(&gb) * 4;
408  if (slice_size + off > buf_size || !slice_size) {
409  av_log(avctx, AV_LOG_ERROR,
410  "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
411  return AVERROR_INVALIDDATA;
412  }
413 
414  ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
415  if (ret < 0) {
416  av_log(avctx, AV_LOG_ERROR,
417  "Error decoding slice at %d.%d\n", x, y);
418  return ret;
419  }
420 
421  off += slice_size;
422  }
423  }
424 
425  *got_frame = 1;
426 
427  return avpkt->size;
428 }
429 
431 {
432  AICContext *ctx = avctx->priv_data;
433  int i;
434  uint8_t scan[64];
435 
436  ctx->avctx = avctx;
437 
438  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
439 
440  ff_idctdsp_init(&ctx->idsp, avctx);
441 
442  for (i = 0; i < 64; i++)
443  scan[i] = i;
445  for (i = 0; i < 64; i++)
447 
448  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
449  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
450 
451  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
452  ctx->slice_width = 16;
453  for (i = 1; i < 32; i++) {
454  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
455  ctx->slice_width = ctx->mb_width / i;
456  ctx->num_x_slices = i;
457  break;
458  }
459  }
460 
462  * sizeof(*ctx->slice_data));
463  if (!ctx->slice_data) {
464  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
465 
466  return AVERROR(ENOMEM);
467  }
468 
469  for (i = 0; i < NUM_BANDS; i++)
470  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
471  * aic_band_off[i];
472 
473  return 0;
474 }
475 
477 {
478  AICContext *ctx = avctx->priv_data;
479 
480  av_freep(&ctx->slice_data);
481 
482  return 0;
483 }
484 
486  .name = "aic",
487  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
488  .type = AVMEDIA_TYPE_VIDEO,
489  .id = AV_CODEC_ID_AIC,
490  .priv_data_size = sizeof(AICContext),
492  .close = aic_decode_close,
494  .capabilities = AV_CODEC_CAP_DR1,
495 };
static const int aic_num_band_coeffs[NUM_BANDS]
Definition: aic.c:44
AICBands
Definition: aic.c:36
void(* put_signed_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size)
Definition: idctdsp.h:56
int16_t * data_ptr[NUM_BANDS]
Definition: aic.c:152
const char const char void * val
Definition: avisynth_c.h:634
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
AVCodecContext * avctx
Definition: aic.c:140
#define C
#define AIC_HDR_SIZE
Definition: aic.c:33
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:261
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:1434
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1732
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
uint8_t permutated[64]
Definition: idctdsp.h:31
#define blk(i)
Definition: sha.c:185
AVCodec ff_aic_decoder
Definition: aic.c:485
AVCodec.
Definition: avcodec.h:3482
#define FFALIGN(x, a)
Definition: common.h:97
uint8_t
#define av_cold
Definition: attributes.h:74
static const uint8_t aic_c_scan[64]
Definition: aic.c:97
#define mb
#define Y
Definition: vf_boxblur.c:76
#define AV_RB32
Definition: intreadwrite.h:130
uint8_t * data
Definition: avcodec.h:1433
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:101
#define av_log(a,...)
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:594
static av_cold int aic_decode_init(AVCodecContext *avctx)
Definition: aic.c:430
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int mb_width
Definition: aic.c:147
static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
Definition: aic.c:158
static const uint8_t aic_y_scan[64]
Definition: aic.c:59
#define AV_RB16
Definition: intreadwrite.h:53
#define AVERROR(e)
Definition: error.h:43
IDCTDSPContext idsp
Definition: aic.c:142
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:178
int interlaced
Definition: aic.c:149
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:476
const char * name
Name of the codec implementation.
Definition: avcodec.h:3489
static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)
Definition: aic.c:201
Libavcodec external API header.
int16_t block[64]
Definition: aic.c:154
static const uint8_t aic_c_ext_scan[192]
Definition: aic.c:108
int16_t * slice_data
Definition: aic.c:151
static const uint8_t *const aic_scan[NUM_BANDS]
Definition: aic.c:135
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
#define FFMIN(a, b)
Definition: common.h:92
float y
int width
picture width / height.
Definition: avcodec.h:1691
int quant
Definition: aic.c:148
static const uint8_t aic_quant_matrix[64]
Definition: aic.c:48
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
static const int aic_band_off[NUM_BANDS]
Definition: aic.c:46
Definition: aic.c:41
int frame_size
Definition: mxfenc.c:1819
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)
Definition: aic.c:307
AVS_Value src
Definition: avisynth_c.h:482
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
main external API structure.
Definition: avcodec.h:1512
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:1048
void * buf
Definition: avisynth_c.h:553
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:305
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:298
Definition: aic.c:37
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:415
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
Definition: aic.c:294
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:252
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:521
ScanTable scantable
Definition: aic.c:143
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:67
common internal api header.
int mb_height
Definition: aic.c:147
AVFrame * frame
Definition: aic.c:141
static void recombine_block_il(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext, int block_no)
Definition: aic.c:272
#define GET_CODE(val, type, add_bits)
Definition: aic.c:191
void * priv_data
Definition: avcodec.h:1554
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:241
int slice_width
Definition: aic.c:146
static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: aic.c:371
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
int num_x_slices
Definition: aic.c:145
#define av_freep(p)
#define AIC_BAND_COEFFS
Definition: aic.c:34
#define av_malloc_array(a, b)
static const uint8_t aic_y_ext_scan[192]
Definition: aic.c:70
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1410
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:857
uint8_t quant_matrix[64]
Definition: aic.c:155
void(* idct)(int16_t *block)
Definition: idctdsp.h:63
static int width
static int16_t block[64]
Definition: dct-test.c:110