FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups 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 "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  has_skips = get_bits1(gb);
212  coeff_type = get_bits1(gb);
213  coeff_bits = get_bits(gb, 3);
214 
215  if (has_skips) {
216  skip_type = get_bits1(gb);
217  skip_bits = get_bits(gb, 3);
218 
219  for (mb = 0; mb < slice_width; mb++) {
220  idx = -1;
221  do {
222  GET_CODE(val, skip_type, skip_bits);
223  if (val >= 0x10000)
224  return AVERROR_INVALIDDATA;
225  idx += val + 1;
226  if (idx >= num_coeffs)
227  break;
228  GET_CODE(val, coeff_type, coeff_bits);
229  val++;
230  if (val >= 0x10000)
231  return AVERROR_INVALIDDATA;
232  dst[scan[idx]] = val;
233  } while (idx < num_coeffs - 1);
234  dst += num_coeffs;
235  }
236  } else {
237  for (mb = 0; mb < slice_width; mb++) {
238  for (idx = 0; idx < num_coeffs; idx++) {
239  GET_CODE(val, coeff_type, coeff_bits);
240  if (val >= 0x10000)
241  return AVERROR_INVALIDDATA;
242  dst[scan[idx]] = val;
243  }
244  dst += num_coeffs;
245  }
246  }
247  return 0;
248 }
249 
250 static void recombine_block(int16_t *dst, const uint8_t *scan,
251  int16_t **base, int16_t **ext)
252 {
253  int i, j;
254 
255  for (i = 0; i < 4; i++) {
256  for (j = 0; j < 4; j++)
257  dst[scan[i * 8 + j]] = (*base)[j];
258  for (j = 0; j < 4; j++)
259  dst[scan[i * 8 + j + 4]] = (*ext)[j];
260  *base += 4;
261  *ext += 4;
262  }
263  for (; i < 8; i++) {
264  for (j = 0; j < 8; j++)
265  dst[scan[i * 8 + j]] = (*ext)[j];
266  *ext += 8;
267  }
268 }
269 
270 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
271  int16_t **base, int16_t **ext,
272  int block_no)
273 {
274  int i, j;
275 
276  if (block_no < 2) {
277  for (i = 0; i < 8; i++) {
278  for (j = 0; j < 4; j++)
279  dst[scan[i * 8 + j]] = (*base)[j];
280  for (j = 0; j < 4; j++)
281  dst[scan[i * 8 + j + 4]] = (*ext)[j];
282  *base += 4;
283  *ext += 4;
284  }
285  } else {
286  for (i = 0; i < 64; i++)
287  dst[scan[i]] = (*ext)[i];
288  *ext += 64;
289  }
290 }
291 
292 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
293 {
294  int i;
295 
296  for (i = 0; i < 64; i++) {
297  int val = (uint16_t)block[i];
298  int sign = val & 1;
299 
300  block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
301  + sign;
302  }
303 }
304 
305 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
306  const uint8_t *src, int src_size)
307 {
308  GetBitContext gb;
309  int ret, i, mb, blk;
310  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
311  uint8_t *Y, *C[2];
312  uint8_t *dst;
313  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
314  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
315  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
316  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
317  const int ystride = ctx->frame->linesize[0];
318 
319  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
320  for (i = 0; i < 2; i++)
321  C[i] = ctx->frame->data[i + 1] + mb_x * 8
322  + mb_y * 8 * ctx->frame->linesize[i + 1];
323  init_get_bits(&gb, src, src_size * 8);
324 
325  memset(ctx->slice_data, 0,
326  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
327  for (i = 0; i < NUM_BANDS; i++)
328  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
329  i, slice_width,
330  !ctx->interlaced)) < 0)
331  return ret;
332 
333  for (mb = 0; mb < slice_width; mb++) {
334  for (blk = 0; blk < 4; blk++) {
335  if (!ctx->interlaced)
337  &base_y, &ext_y);
338  else
340  &base_y, &ext_y, blk);
341  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
342  ctx->idsp.idct(ctx->block);
343 
344  if (!ctx->interlaced) {
345  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
346  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
347  } else {
348  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
349  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
350  ystride * 2);
351  }
352  }
353  Y += 16;
354 
355  for (blk = 0; blk < 2; blk++) {
357  &base_c, &ext_c);
358  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
359  ctx->idsp.idct(ctx->block);
360  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
361  ctx->frame->linesize[blk + 1]);
362  C[blk] += 8;
363  }
364  }
365 
366  return 0;
367 }
368 
369 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
370  AVPacket *avpkt)
371 {
372  AICContext *ctx = avctx->priv_data;
373  const uint8_t *buf = avpkt->data;
374  int buf_size = avpkt->size;
375  GetByteContext gb;
376  uint32_t off;
377  int x, y, ret;
378  int slice_size;
379  ThreadFrame frame = { .f = data };
380 
381  ctx->frame = data;
383  ctx->frame->key_frame = 1;
384 
385  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
386 
387  if (buf_size < off) {
388  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
389  return AVERROR_INVALIDDATA;
390  }
391 
392  ret = aic_decode_header(ctx, buf, buf_size);
393  if (ret < 0) {
394  av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
395  return ret;
396  }
397 
398  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
399  return ret;
400 
401  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
402  ctx->num_x_slices * ctx->mb_height * 2);
403 
404  for (y = 0; y < ctx->mb_height; y++) {
405  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
406  slice_size = bytestream2_get_le16(&gb) * 4;
407  if (slice_size + off > buf_size || !slice_size) {
408  av_log(avctx, AV_LOG_ERROR,
409  "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
410  return AVERROR_INVALIDDATA;
411  }
412 
413  ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
414  if (ret < 0) {
415  av_log(avctx, AV_LOG_ERROR,
416  "Error decoding slice at %d.%d\n", x, y);
417  return ret;
418  }
419 
420  off += slice_size;
421  }
422  }
423 
424  *got_frame = 1;
425 
426  return avpkt->size;
427 }
428 
430 {
431  AICContext *ctx = avctx->priv_data;
432  int i;
433  uint8_t scan[64];
434 
435  ctx->avctx = avctx;
436 
437  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
438 
439  ff_idctdsp_init(&ctx->idsp, avctx);
440 
441  for (i = 0; i < 64; i++)
442  scan[i] = i;
444  for (i = 0; i < 64; i++)
446 
447  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
448  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
449 
450  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
451  ctx->slice_width = 16;
452  for (i = 1; i < ctx->mb_width; i++) {
453  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
454  ctx->slice_width = ctx->mb_width / i;
455  ctx->num_x_slices = i;
456  break;
457  }
458  }
459 
461  * sizeof(*ctx->slice_data));
462  if (!ctx->slice_data) {
463  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
464 
465  return AVERROR(ENOMEM);
466  }
467 
468  for (i = 0; i < NUM_BANDS; i++)
469  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
470  * aic_band_off[i];
471 
472  return 0;
473 }
474 
476 {
477  AICContext *ctx = avctx->priv_data;
478 
479  av_freep(&ctx->slice_data);
480 
481  return 0;
482 }
483 
485  .name = "aic",
486  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
487  .type = AVMEDIA_TYPE_VIDEO,
488  .id = AV_CODEC_ID_AIC,
489  .priv_data_size = sizeof(AICContext),
491  .close = aic_decode_close,
495  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
496 };
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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
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:261
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:1401
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1697
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
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
#define blk(i)
Definition: sha.c:185
AVCodec ff_aic_decoder
Definition: aic.c:484
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3351
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static int16_t block[64]
Definition: dct.c:115
#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
Multithreading support functions.
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_RB32
Definition: bytestream.h:87
static AVFrame * frame
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
#define height
uint8_t * data
Definition: avcodec.h:1400
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:101
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
static av_cold int aic_decode_init(AVCodecContext *avctx)
Definition: aic.c:429
#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 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:186
int interlaced
Definition: aic.c:150
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:475
uint16_t width
Definition: gdv.c:47
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)
Definition: aic.c:202
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1012
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:225
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:1660
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:1947
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)
Definition: aic.c:305
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:1488
void * buf
Definition: avisynth_c.h:690
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:313
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:306
Definition: aic.c:38
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:425
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
Definition: aic.c:292
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:250
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:62
common internal api header.
void(* put_signed_pixels_clamped)(const int16_t *block, uint8_t *av_restrict pixels, ptrdiff_t line_size)
Definition: idctdsp.h:58
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:270
#define GET_CODE(val, type, add_bits)
Definition: aic.c:192
void * priv_data
Definition: avcodec.h:1515
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:369
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
exp golomb vlc stuff
This structure stores compressed data.
Definition: avcodec.h:1377
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
uint8_t quant_matrix[64]
Definition: aic.c:156
void(* idct)(int16_t *block)
Definition: idctdsp.h:65