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