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