Libav
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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 *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];
155 } AICContext;
156 
157 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
158 {
159  uint32_t frame_size;
160  int width, height;
161 
162  if (src[0] != 1) {
163  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
164  return AVERROR_INVALIDDATA;
165  }
166  if (src[1] != AIC_HDR_SIZE - 2) {
167  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
168  return AVERROR_INVALIDDATA;
169  }
170  frame_size = AV_RB32(src + 2);
171  width = AV_RB16(src + 6);
172  height = AV_RB16(src + 8);
173  if (frame_size > size) {
174  av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
175  frame_size, size);
176  return AVERROR_INVALIDDATA;
177  }
178  if (width != ctx->avctx->width || height != ctx->avctx->height) {
179  av_log(ctx->avctx, AV_LOG_ERROR,
180  "Picture dimension changed: old: %d x %d, new: %d x %d\n",
181  ctx->avctx->width, ctx->avctx->height, width, height);
182  return AVERROR_INVALIDDATA;
183  }
184  ctx->quant = src[15];
185  ctx->interlaced = ((src[16] >> 4) == 3);
186 
187  return 0;
188 }
189 
190 #define GET_CODE(val, type, add_bits) \
191  do { \
192  if (type) \
193  val = get_ue_golomb(gb); \
194  else \
195  val = get_unary(gb, 1, 31); \
196  if (add_bits) \
197  val = (val << add_bits) + get_bits(gb, add_bits); \
198  } while (0)
199 
200 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
201  int band, int slice_width, int force_chroma)
202 {
203  int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
204  const int num_coeffs = aic_num_band_coeffs[band];
205  const uint8_t *scan = aic_scan[band | force_chroma];
206  int mb, idx, val;
207 
208  has_skips = get_bits1(gb);
209  coeff_type = get_bits1(gb);
210  coeff_bits = get_bits(gb, 3);
211 
212  if (has_skips) {
213  skip_type = get_bits1(gb);
214  skip_bits = get_bits(gb, 3);
215 
216  for (mb = 0; mb < slice_width; mb++) {
217  idx = -1;
218  do {
219  GET_CODE(val, skip_type, skip_bits);
220  if (val < 0)
221  return AVERROR_INVALIDDATA;
222  idx += val + 1;
223  if (idx >= num_coeffs)
224  break;
225  GET_CODE(val, coeff_type, coeff_bits);
226  val++;
227  if (val >= 0x10000 || val < 0)
228  return AVERROR_INVALIDDATA;
229  dst[scan[idx]] = val;
230  } while (idx < num_coeffs - 1);
231  dst += num_coeffs;
232  }
233  } else {
234  for (mb = 0; mb < slice_width; mb++) {
235  for (idx = 0; idx < num_coeffs; idx++) {
236  GET_CODE(val, coeff_type, coeff_bits);
237  if (val >= 0x10000 || val < 0)
238  return AVERROR_INVALIDDATA;
239  dst[scan[idx]] = val;
240  }
241  dst += num_coeffs;
242  }
243  }
244  return 0;
245 }
246 
247 static void recombine_block(int16_t *dst, const uint8_t *scan,
248  int16_t **base, int16_t **ext)
249 {
250  int i, j;
251 
252  for (i = 0; i < 4; i++) {
253  for (j = 0; j < 4; j++)
254  dst[scan[i * 8 + j]] = (*base)[j];
255  for (j = 0; j < 4; j++)
256  dst[scan[i * 8 + j + 4]] = (*ext)[j];
257  *base += 4;
258  *ext += 4;
259  }
260  for (; i < 8; i++) {
261  for (j = 0; j < 8; j++)
262  dst[scan[i * 8 + j]] = (*ext)[j];
263  *ext += 8;
264  }
265 }
266 
267 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
268  int16_t **base, int16_t **ext,
269  int block_no)
270 {
271  int i, j;
272 
273  if (block_no < 2) {
274  for (i = 0; i < 8; i++) {
275  for (j = 0; j < 4; j++)
276  dst[scan[i * 8 + j]] = (*base)[j];
277  for (j = 0; j < 4; j++)
278  dst[scan[i * 8 + j + 4]] = (*ext)[j];
279  *base += 4;
280  *ext += 4;
281  }
282  } else {
283  for (i = 0; i < 64; i++)
284  dst[scan[i]] = (*ext)[i];
285  *ext += 64;
286  }
287 }
288 
289 static void unquant_block(int16_t *block, int q)
290 {
291  int i;
292 
293  for (i = 0; i < 64; i++) {
294  int val = (uint16_t)block[i];
295  int sign = val & 1;
296 
297  block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
298  + sign;
299  }
300 }
301 
302 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
303  const uint8_t *src, int src_size)
304 {
305  GetBitContext gb;
306  int ret, i, mb, blk;
307  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
308  uint8_t *Y, *C[2];
309  uint8_t *dst;
310  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
311  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
312  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
313  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
314  const int ystride = ctx->frame->linesize[0];
315 
316  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
317  for (i = 0; i < 2; i++)
318  C[i] = ctx->frame->data[i + 1] + mb_x * 8
319  + mb_y * 8 * ctx->frame->linesize[i + 1];
320  init_get_bits(&gb, src, src_size * 8);
321 
322  memset(ctx->slice_data, 0,
323  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
324  for (i = 0; i < NUM_BANDS; i++)
325  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
326  i, slice_width,
327  !ctx->interlaced)) < 0)
328  return ret;
329 
330  for (mb = 0; mb < slice_width; mb++) {
331  for (blk = 0; blk < 4; blk++) {
332  if (!ctx->interlaced)
334  &base_y, &ext_y);
335  else
337  &base_y, &ext_y, blk);
338  unquant_block(ctx->block, ctx->quant);
339  ctx->idsp.idct(ctx->block);
340 
341  if (!ctx->interlaced) {
342  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
343  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
344  } else {
345  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
346  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
347  ystride * 2);
348  }
349  }
350  Y += 16;
351 
352  for (blk = 0; blk < 2; blk++) {
354  &base_c, &ext_c);
355  unquant_block(ctx->block, ctx->quant);
356  ctx->idsp.idct(ctx->block);
357  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
358  ctx->frame->linesize[blk + 1]);
359  C[blk] += 8;
360  }
361  }
362 
363  return 0;
364 }
365 
366 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
367  AVPacket *avpkt)
368 {
369  AICContext *ctx = avctx->priv_data;
370  const uint8_t *buf = avpkt->data;
371  int buf_size = avpkt->size;
372  GetByteContext gb;
373  uint32_t off;
374  int x, y, ret;
375  int slice_size;
376 
377  ctx->frame = data;
379  ctx->frame->key_frame = 1;
380 
381  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
382 
383  if (buf_size < off) {
384  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
385  return AVERROR_INVALIDDATA;
386  }
387 
388  if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
389  return ret;
390 
391  if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
392  return ret;
393 
394  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
395  ctx->num_x_slices * ctx->mb_height * 2);
396 
397  for (y = 0; y < ctx->mb_height; y++) {
398  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
399  slice_size = bytestream2_get_le16(&gb) * 4;
400  if (slice_size + off > buf_size || !slice_size) {
401  av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
402  return AVERROR_INVALIDDATA;
403  }
404 
405  if ((ret = aic_decode_slice(ctx, x, y,
406  buf + off, slice_size)) < 0)
407  return ret;
408 
409  off += slice_size;
410  }
411  }
412 
413  *got_frame = 1;
414 
415  return avpkt->size;
416 }
417 
419 {
420  AICContext *ctx = avctx->priv_data;
421  int i;
422  uint8_t scan[64];
423 
424  ctx->avctx = avctx;
425 
426  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
427 
428  ff_idctdsp_init(&ctx->idsp, avctx);
429 
430  for (i = 0; i < 64; i++)
431  scan[i] = i;
433 
434  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
435  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
436 
437  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
438  ctx->slice_width = 16;
439  for (i = 1; i < 32; i++) {
440  if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
441  ctx->slice_width = ctx->mb_width / i;
442  ctx->num_x_slices = i;
443  break;
444  }
445  }
446 
448  * sizeof(*ctx->slice_data));
449  if (!ctx->slice_data) {
450  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
451 
452  return AVERROR(ENOMEM);
453  }
454 
455  for (i = 0; i < NUM_BANDS; i++)
456  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
457  * aic_band_off[i];
458 
459  return 0;
460 }
461 
463 {
464  AICContext *ctx = avctx->priv_data;
465 
466  av_freep(&ctx->slice_data);
467 
468  return 0;
469 }
470 
472  .name = "aic",
473  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
474  .type = AVMEDIA_TYPE_VIDEO,
475  .id = AV_CODEC_ID_AIC,
476  .priv_data_size = sizeof(AICContext),
480  .capabilities = CODEC_CAP_DR1,
481 };
static const int aic_num_band_coeffs[NUM_BANDS]
Definition: aic.c:44
AICBands
Definition: aic.c:36
int16_t * data_ptr[NUM_BANDS]
Definition: aic.c:152
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
int size
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
AVCodecContext * avctx
Definition: aic.c:140
#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:240
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:974
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1254
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
uint8_t permutated[64]
Definition: idctdsp.h:31
#define blk(i)
Definition: sha.c:173
AVCodec ff_aic_decoder
Definition: aic.c:471
AVCodec.
Definition: avcodec.h:2796
#define FFALIGN(x, a)
Definition: common.h:62
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
uint8_t
#define av_cold
Definition: attributes.h:66
static const uint8_t aic_c_scan[64]
Definition: aic.c:97
#define AV_RB32
Definition: intreadwrite.h:130
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
bitstream reader API header.
static const uint8_t * aic_scan[NUM_BANDS]
Definition: aic.c:135
static void unquant_block(int16_t *block, int q)
Definition: aic.c:289
Definition: vf_drawbox.c:37
static const uint8_t frame_size[4]
Definition: g723_1_data.h:47
static av_cold int aic_decode_init(AVCodecContext *avctx)
Definition: aic.c:418
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int mb_width
Definition: aic.c:147
static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
Definition: aic.c:157
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:150
int interlaced
Definition: aic.c:149
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:462
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2803
static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)
Definition: aic.c:200
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
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:196
#define FFMIN(a, b)
Definition: common.h:57
int width
picture width / height.
Definition: avcodec.h:1224
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
static int width
Definition: utils.c:156
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)
Definition: aic.c:302
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:612
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
Definition: aic.c:37
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:247
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
int height
Definition: gxfenc.c:72
ScanTable scantable
Definition: aic.c:143
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
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:267
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
#define GET_CODE(val, type, add_bits)
Definition: aic.c:190
void * priv_data
Definition: avcodec.h:1092
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:28
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:156
int slice_width
Definition: aic.c:146
static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: aic.c:366
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:191
void(* put_signed_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size)
Definition: idctdsp.h:56
int num_x_slices
Definition: aic.c:145
#define AIC_BAND_COEFFS
Definition: aic.c:34
static const uint8_t aic_y_ext_scan[192]
Definition: aic.c:70
void(* idct)(int16_t *block)
Definition: idctdsp.h:63
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:950
static int16_t block[64]
Definition: dct-test.c:88