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 "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  has_skips = get_bits1(gb);
211  coeff_type = get_bits1(gb);
212  coeff_bits = get_bits(gb, 3);
213 
214  if (has_skips) {
215  skip_type = get_bits1(gb);
216  skip_bits = get_bits(gb, 3);
217 
218  for (mb = 0; mb < slice_width; mb++) {
219  idx = -1;
220  do {
221  GET_CODE(val, skip_type, skip_bits);
222  if (val >= 0x10000)
223  return AVERROR_INVALIDDATA;
224  idx += val + 1;
225  if (idx >= num_coeffs)
226  break;
227  GET_CODE(val, coeff_type, coeff_bits);
228  val++;
229  if (val >= 0x10000)
230  return AVERROR_INVALIDDATA;
231  dst[scan[idx]] = val;
232  } while (idx < num_coeffs - 1);
233  dst += num_coeffs;
234  }
235  } else {
236  for (mb = 0; mb < slice_width; mb++) {
237  for (idx = 0; idx < num_coeffs; idx++) {
238  GET_CODE(val, coeff_type, coeff_bits);
239  if (val >= 0x10000)
240  return AVERROR_INVALIDDATA;
241  dst[scan[idx]] = val;
242  }
243  dst += num_coeffs;
244  }
245  }
246  return 0;
247 }
248 
249 static void recombine_block(int16_t *dst, const uint8_t *scan,
250  int16_t **base, int16_t **ext)
251 {
252  int i, j;
253 
254  for (i = 0; i < 4; i++) {
255  for (j = 0; j < 4; j++)
256  dst[scan[i * 8 + j]] = (*base)[j];
257  for (j = 0; j < 4; j++)
258  dst[scan[i * 8 + j + 4]] = (*ext)[j];
259  *base += 4;
260  *ext += 4;
261  }
262  for (; i < 8; i++) {
263  for (j = 0; j < 8; j++)
264  dst[scan[i * 8 + j]] = (*ext)[j];
265  *ext += 8;
266  }
267 }
268 
269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
270  int16_t **base, int16_t **ext,
271  int block_no)
272 {
273  int i, j;
274 
275  if (block_no < 2) {
276  for (i = 0; i < 8; i++) {
277  for (j = 0; j < 4; j++)
278  dst[scan[i * 8 + j]] = (*base)[j];
279  for (j = 0; j < 4; j++)
280  dst[scan[i * 8 + j + 4]] = (*ext)[j];
281  *base += 4;
282  *ext += 4;
283  }
284  } else {
285  for (i = 0; i < 64; i++)
286  dst[scan[i]] = (*ext)[i];
287  *ext += 64;
288  }
289 }
290 
291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
292 {
293  int i;
294 
295  for (i = 0; i < 64; i++) {
296  int val = (uint16_t)block[i];
297  int sign = val & 1;
298 
299  block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
300  + sign;
301  }
302 }
303 
304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
305  const uint8_t *src, int src_size)
306 {
307  GetBitContext gb;
308  int ret, i, mb, blk;
309  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
310  uint8_t *Y, *C[2];
311  uint8_t *dst;
312  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
313  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
314  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
315  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
316  const int ystride = ctx->frame->linesize[0];
317 
318  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
319  for (i = 0; i < 2; i++)
320  C[i] = ctx->frame->data[i + 1] + mb_x * 8
321  + mb_y * 8 * ctx->frame->linesize[i + 1];
322  init_get_bits(&gb, src, src_size * 8);
323 
324  memset(ctx->slice_data, 0,
325  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
326  for (i = 0; i < NUM_BANDS; i++)
327  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
328  i, slice_width,
329  !ctx->interlaced)) < 0)
330  return ret;
331 
332  for (mb = 0; mb < slice_width; mb++) {
333  for (blk = 0; blk < 4; blk++) {
334  if (!ctx->interlaced)
336  &base_y, &ext_y);
337  else
339  &base_y, &ext_y, blk);
340  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
341  ctx->idsp.idct(ctx->block);
342 
343  if (!ctx->interlaced) {
344  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
345  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
346  } else {
347  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
348  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
349  ystride * 2);
350  }
351  }
352  Y += 16;
353 
354  for (blk = 0; blk < 2; blk++) {
356  &base_c, &ext_c);
357  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
358  ctx->idsp.idct(ctx->block);
359  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
360  ctx->frame->linesize[blk + 1]);
361  C[blk] += 8;
362  }
363  }
364 
365  return 0;
366 }
367 
368 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
369  AVPacket *avpkt)
370 {
371  AICContext *ctx = avctx->priv_data;
372  const uint8_t *buf = avpkt->data;
373  int buf_size = avpkt->size;
374  GetByteContext gb;
375  uint32_t off;
376  int x, y, ret;
377  int slice_size;
378 
379  ctx->frame = data;
381  ctx->frame->key_frame = 1;
382 
383  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
384 
385  if (buf_size < off) {
386  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
387  return AVERROR_INVALIDDATA;
388  }
389 
390  ret = aic_decode_header(ctx, buf, buf_size);
391  if (ret < 0) {
392  av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
393  return ret;
394  }
395 
396  if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
397  return ret;
398 
399  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
400  ctx->num_x_slices * ctx->mb_height * 2);
401 
402  for (y = 0; y < ctx->mb_height; y++) {
403  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
404  slice_size = bytestream2_get_le16(&gb) * 4;
405  if (slice_size + off > buf_size || !slice_size) {
406  av_log(avctx, AV_LOG_ERROR,
407  "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
408  return AVERROR_INVALIDDATA;
409  }
410 
411  ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
412  if (ret < 0) {
413  av_log(avctx, AV_LOG_ERROR,
414  "Error decoding slice at %d.%d\n", x, y);
415  return ret;
416  }
417 
418  off += slice_size;
419  }
420  }
421 
422  *got_frame = 1;
423 
424  return avpkt->size;
425 }
426 
428 {
429  AICContext *ctx = avctx->priv_data;
430  int i;
431  uint8_t scan[64];
432 
433  ctx->avctx = avctx;
434 
435  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
436 
437  ff_idctdsp_init(&ctx->idsp, avctx);
438 
439  for (i = 0; i < 64; i++)
440  scan[i] = i;
442  for (i = 0; i < 64; i++)
444 
445  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
446  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
447 
448  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
449  ctx->slice_width = 16;
450  for (i = 1; i < 32; i++) {
451  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
452  ctx->slice_width = ctx->mb_width / i;
453  ctx->num_x_slices = i;
454  break;
455  }
456  }
457 
459  * sizeof(*ctx->slice_data));
460  if (!ctx->slice_data) {
461  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
462 
463  return AVERROR(ENOMEM);
464  }
465 
466  for (i = 0; i < NUM_BANDS; i++)
467  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
468  * aic_band_off[i];
469 
470  return 0;
471 }
472 
474 {
475  AICContext *ctx = avctx->priv_data;
476 
477  av_freep(&ctx->slice_data);
478 
479  return 0;
480 }
481 
483  .name = "aic",
484  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
485  .type = AVMEDIA_TYPE_VIDEO,
486  .id = AV_CODEC_ID_AIC,
487  .priv_data_size = sizeof(AICContext),
489  .close = aic_decode_close,
491  .capabilities = AV_CODEC_CAP_DR1,
492 };
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:181
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
AVCodecContext * avctx
Definition: aic.c:140
#define C
AVFormatContext * ctx
Definition: movenc-test.c:48
#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:260
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:1468
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1752
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
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:482
AVCodec.
Definition: avcodec.h:3392
uint8_t
#define av_cold
Definition: attributes.h:82
static const uint8_t aic_c_scan[64]
Definition: aic.c:97
#define mb
#define Y
Definition: vf_boxblur.c:76
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
uint8_t * data
Definition: avcodec.h:1467
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:427
#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 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:176
int interlaced
Definition: aic.c:149
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:473
const char * name
Name of the codec implementation.
Definition: avcodec.h:3399
static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)
Definition: aic.c:201
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:252
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1711
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
#define src
Definition: vp9dsp.c:530
static const int aic_band_off[NUM_BANDS]
Definition: aic.c:46
Definition: aic.c:41
int frame_size
Definition: mxfenc.c:1821
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)
Definition: aic.c:304
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:209
main external API structure.
Definition: avcodec.h:1532
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:894
void * buf
Definition: avisynth_c.h:553
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:312
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:305
Definition: aic.c:37
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:418
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
Definition: aic.c:291
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:249
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:192
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:572
ScanTable scantable
Definition: aic.c:143
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
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:269
#define GET_CODE(val, type, add_bits)
Definition: aic.c:191
void * priv_data
Definition: avcodec.h:1574
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:368
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:247
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:1444
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:856
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:112