FFmpeg
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 uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46 
47 static const uint16_t 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  int last_row = mb_y && mb_y == ctx->mb_height - 1;
315  int y_pos, c_pos;
316  uint8_t *Y, *C[2];
317  uint8_t *dst;
318  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
319  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
320  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
321  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
322  const int ystride = ctx->frame->linesize[0];
323 
324  if (last_row) {
325  y_pos = (ctx->avctx->height - 16);
326  c_pos = ((ctx->avctx->height+1)/2 - 8);
327  } else {
328  y_pos = mb_y * 16;
329  c_pos = mb_y * 8;
330  }
331 
332  Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
333  for (i = 0; i < 2; i++)
334  C[i] = ctx->frame->data[i + 1] + mb_x * 8
335  + c_pos * ctx->frame->linesize[i + 1];
336  init_get_bits(&gb, src, src_size * 8);
337 
338  memset(ctx->slice_data, 0,
339  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
340  for (i = 0; i < NUM_BANDS; i++)
341  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
342  i, slice_width,
343  !ctx->interlaced)) < 0)
344  return ret;
345 
346  for (mb = 0; mb < slice_width; mb++) {
347  for (blk = 0; blk < 4; blk++) {
348  if (!ctx->interlaced)
349  recombine_block(ctx->block, ctx->scantable.permutated,
350  &base_y, &ext_y);
351  else
352  recombine_block_il(ctx->block, ctx->scantable.permutated,
353  &base_y, &ext_y, blk);
354  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
355  ctx->idsp.idct(ctx->block);
356 
357  if (!ctx->interlaced) {
358  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
359  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
360  } else {
361  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
362  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
363  ystride * 2);
364  }
365  }
366  Y += 16;
367 
368  for (blk = 0; blk < 2; blk++) {
369  recombine_block(ctx->block, ctx->scantable.permutated,
370  &base_c, &ext_c);
371  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
372  ctx->idsp.idct(ctx->block);
373  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
374  ctx->frame->linesize[blk + 1]);
375  C[blk] += 8;
376  }
377  }
378 
379  return 0;
380 }
381 
382 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
383  AVPacket *avpkt)
384 {
385  AICContext *ctx = avctx->priv_data;
386  const uint8_t *buf = avpkt->data;
387  int buf_size = avpkt->size;
388  GetByteContext gb;
389  uint32_t off;
390  int x, y, ret;
391  int slice_size;
392  ThreadFrame frame = { .f = data };
393 
394  ctx->frame = data;
395  ctx->frame->pict_type = AV_PICTURE_TYPE_I;
396  ctx->frame->key_frame = 1;
397 
398  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
399 
400  if (buf_size < off) {
401  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
402  return AVERROR_INVALIDDATA;
403  }
404 
405  ret = aic_decode_header(ctx, buf, buf_size);
406  if (ret < 0) {
407  av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
408  return ret;
409  }
410 
411  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
412  return ret;
413 
414  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
415  ctx->num_x_slices * ctx->mb_height * 2);
416 
417  for (y = 0; y < ctx->mb_height; y++) {
418  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
419  slice_size = bytestream2_get_le16(&gb) * 4;
420  if (slice_size + off > buf_size || !slice_size) {
421  av_log(avctx, AV_LOG_ERROR,
422  "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
423  return AVERROR_INVALIDDATA;
424  }
425 
426  ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
427  if (ret < 0) {
428  av_log(avctx, AV_LOG_ERROR,
429  "Error decoding slice at %d.%d\n", x, y);
430  return ret;
431  }
432 
433  off += slice_size;
434  }
435  }
436 
437  *got_frame = 1;
438 
439  return avpkt->size;
440 }
441 
443 {
444  AICContext *ctx = avctx->priv_data;
445  int i;
446  uint8_t scan[64];
447 
448  ctx->avctx = avctx;
449 
450  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
451 
452  ff_idctdsp_init(&ctx->idsp, avctx);
453 
454  for (i = 0; i < 64; i++)
455  scan[i] = i;
456  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
457  for (i = 0; i < 64; i++)
458  ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
459 
460  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
461  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
462 
463  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
464  ctx->slice_width = 16;
465  for (i = 1; i < ctx->mb_width; i++) {
466  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
467  ctx->slice_width = ctx->mb_width / i;
468  ctx->num_x_slices = i;
469  break;
470  }
471  }
472 
473  ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
474  * sizeof(*ctx->slice_data));
475  if (!ctx->slice_data) {
476  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
477 
478  return AVERROR(ENOMEM);
479  }
480 
481  for (i = 0; i < NUM_BANDS; i++)
482  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
483  * aic_band_off[i];
484 
485  return 0;
486 }
487 
489 {
490  AICContext *ctx = avctx->priv_data;
491 
492  av_freep(&ctx->slice_data);
493 
494  return 0;
495 }
496 
498  .name = "aic",
499  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
500  .type = AVMEDIA_TYPE_VIDEO,
501  .id = AV_CODEC_ID_AIC,
502  .priv_data_size = sizeof(AICContext),
504  .close = aic_decode_close,
507  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
508 };
AVCodec
AVCodec.
Definition: codec.h:190
AIC_HDR_SIZE
#define AIC_HDR_SIZE
Definition: aic.c:34
FF_CODEC_CAP_INIT_THREADSAFE
#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
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
GetByteContext
Definition: bytestream.h:33
unquant_block
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
Definition: aic.c:295
aic_c_scan
static const uint8_t aic_c_scan[64]
Definition: aic.c:98
AICContext::block
int16_t block[64]
Definition: aic.c:155
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
recombine_block
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:253
data
const char data[16]
Definition: mxf.c:91
base
uint8_t base
Definition: vp3data.h:202
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
thread.h
AICContext::frame
AVFrame * frame
Definition: aic.c:142
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AICBands
AICBands
Definition: aic.c:37
GetBitContext
Definition: get_bits.h:61
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
COEFF_CHROMA_EXT
@ COEFF_CHROMA_EXT
Definition: aic.c:41
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AICContext::scantable
ScanTable scantable
Definition: aic.c:144
AICContext::mb_height
int mb_height
Definition: aic.c:148
C
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
Definition: writing_filters.txt:58
AICContext::mb_width
int mb_width
Definition: aic.c:148
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
aic_decode_coeffs
static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)
Definition: aic.c:202
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
frame_size
int frame_size
Definition: mxfenc.c:2137
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
blk
#define blk(i)
Definition: sha.c:185
aic_y_ext_scan
static const uint8_t aic_y_ext_scan[192]
Definition: aic.c:71
AICContext::data_ptr
int16_t * data_ptr[NUM_BANDS]
Definition: aic.c:153
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
aic_decode_init
static av_cold int aic_decode_init(AVCodecContext *avctx)
Definition: aic.c:442
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:254
COEFF_LUMA
@ COEFF_LUMA
Definition: aic.c:38
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
size
int size
Definition: twinvq_data.h:11134
AV_RB32
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:92
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
mb
#define mb
Definition: vf_colormatrix.c:101
unary.h
Y
#define Y
Definition: boxblur.h:38
aic_decode_frame
static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: aic.c:382
NUM_BANDS
@ NUM_BANDS
Definition: aic.c:42
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
AICContext::slice_data
int16_t * slice_data
Definition: aic.c:152
AICContext::avctx
AVCodecContext * avctx
Definition: aic.c:141
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
aic_y_scan
static const uint8_t aic_y_scan[64]
Definition: aic.c:60
aic_scan
static const uint8_t *const aic_scan[NUM_BANDS]
Definition: aic.c:136
aic_decode_header
static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
Definition: aic.c:159
AIC_BAND_COEFFS
#define AIC_BAND_COEFFS
Definition: aic.c:35
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
GET_CODE
#define GET_CODE(val, type, add_bits)
Definition: aic.c:192
AICContext::num_x_slices
int num_x_slices
Definition: aic.c:146
aic_c_ext_scan
static const uint8_t aic_c_ext_scan[192]
Definition: aic.c:109
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
idctdsp.h
avcodec.h
aic_num_band_coeffs
static const uint8_t aic_num_band_coeffs[NUM_BANDS]
Definition: aic.c:45
aic_decode_close
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:488
ff_aic_decoder
AVCodec ff_aic_decoder
Definition: aic.c:497
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV_CODEC_ID_AIC
@ AV_CODEC_ID_AIC
Definition: codec_id.h:218
IDCTDSPContext
Definition: idctdsp.h:53
aic_quant_matrix
static const uint8_t aic_quant_matrix[64]
Definition: aic.c:49
AICContext::interlaced
int interlaced
Definition: aic.c:150
COEFF_CHROMA
@ COEFF_CHROMA
Definition: aic.c:39
AVCodecContext
main external API structure.
Definition: avcodec.h:526
ThreadFrame
Definition: thread.h:34
aic_band_off
static const uint16_t aic_band_off[NUM_BANDS]
Definition: aic.c:47
AICContext::quant
int quant
Definition: aic.c:149
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
recombine_block_il
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
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AICContext
Definition: aic.c:140
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
AICContext::quant_matrix
uint8_t quant_matrix[64]
Definition: aic.c:156
aic_decode_slice
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)
Definition: aic.c:308
COEFF_LUMA_EXT
@ COEFF_LUMA_EXT
Definition: aic.c:40
AICContext::slice_width
int slice_width
Definition: aic.c:147
AV_RB16
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:94
AICContext::idsp
IDCTDSPContext idsp
Definition: aic.c:143