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 "codec_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 {
146 
150  int quant;
152 
153  int16_t *slice_data;
154  int16_t *data_ptr[NUM_BANDS];
155 
156  DECLARE_ALIGNED(16, int16_t, block)[64];
157  DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
158 } AICContext;
159 
160 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
161 {
162  uint32_t frame_size;
163  int width, height;
164 
165  if (src[0] != 1) {
166  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
167  return AVERROR_INVALIDDATA;
168  }
169  if (src[1] != AIC_HDR_SIZE - 2) {
170  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
171  return AVERROR_INVALIDDATA;
172  }
173  frame_size = AV_RB32(src + 2);
174  width = AV_RB16(src + 6);
175  height = AV_RB16(src + 8);
176  if (frame_size > size) {
177  av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
178  frame_size, size);
179  return AVERROR_INVALIDDATA;
180  }
181  if (width != ctx->avctx->width || height != ctx->avctx->height) {
182  av_log(ctx->avctx, AV_LOG_ERROR,
183  "Picture dimension changed: old: %d x %d, new: %d x %d\n",
184  ctx->avctx->width, ctx->avctx->height, width, height);
185  return AVERROR_INVALIDDATA;
186  }
187  ctx->quant = src[15];
188  ctx->interlaced = ((src[16] >> 4) == 3);
189 
190  return 0;
191 }
192 
193 #define GET_CODE(val, type, add_bits) \
194  do { \
195  if (type) \
196  val = get_ue_golomb(gb); \
197  else \
198  val = get_unary(gb, 1, 31); \
199  if (add_bits) \
200  val = (val << add_bits) + get_bits(gb, add_bits); \
201  } while (0)
202 
203 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
204  int band, int slice_width, int force_chroma)
205 {
206  int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
207  const int num_coeffs = aic_num_band_coeffs[band];
208  const uint8_t *scan = aic_scan[band | force_chroma];
209  int mb, idx;
210  unsigned val;
211 
212  if (get_bits_left(gb) < 5)
213  return AVERROR_INVALIDDATA;
214 
215  has_skips = get_bits1(gb);
216  coeff_type = get_bits1(gb);
217  coeff_bits = get_bits(gb, 3);
218 
219  if (has_skips) {
220  skip_type = get_bits1(gb);
221  skip_bits = get_bits(gb, 3);
222 
223  for (mb = 0; mb < slice_width; mb++) {
224  idx = -1;
225  do {
226  GET_CODE(val, skip_type, skip_bits);
227  if (val >= 0x10000)
228  return AVERROR_INVALIDDATA;
229  idx += val + 1;
230  if (idx >= num_coeffs)
231  break;
232  GET_CODE(val, coeff_type, coeff_bits);
233  val++;
234  if (val >= 0x10000)
235  return AVERROR_INVALIDDATA;
236  dst[scan[idx]] = val;
237  } while (idx < num_coeffs - 1);
238  dst += num_coeffs;
239  }
240  } else {
241  for (mb = 0; mb < slice_width; mb++) {
242  for (idx = 0; idx < num_coeffs; idx++) {
243  GET_CODE(val, coeff_type, coeff_bits);
244  if (val >= 0x10000)
245  return AVERROR_INVALIDDATA;
246  dst[scan[idx]] = val;
247  }
248  dst += num_coeffs;
249  }
250  }
251  return 0;
252 }
253 
254 static void recombine_block(int16_t *dst, const uint8_t *scan,
255  int16_t **base, int16_t **ext)
256 {
257  int i, j;
258 
259  for (i = 0; i < 4; i++) {
260  for (j = 0; j < 4; j++)
261  dst[scan[i * 8 + j]] = (*base)[j];
262  for (j = 0; j < 4; j++)
263  dst[scan[i * 8 + j + 4]] = (*ext)[j];
264  *base += 4;
265  *ext += 4;
266  }
267  for (; i < 8; i++) {
268  for (j = 0; j < 8; j++)
269  dst[scan[i * 8 + j]] = (*ext)[j];
270  *ext += 8;
271  }
272 }
273 
274 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
275  int16_t **base, int16_t **ext,
276  int block_no)
277 {
278  int i, j;
279 
280  if (block_no < 2) {
281  for (i = 0; i < 8; i++) {
282  for (j = 0; j < 4; j++)
283  dst[scan[i * 8 + j]] = (*base)[j];
284  for (j = 0; j < 4; j++)
285  dst[scan[i * 8 + j + 4]] = (*ext)[j];
286  *base += 4;
287  *ext += 4;
288  }
289  } else {
290  for (i = 0; i < 64; i++)
291  dst[scan[i]] = (*ext)[i];
292  *ext += 64;
293  }
294 }
295 
296 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
297 {
298  int i;
299 
300  for (i = 0; i < 64; i++) {
301  int val = (uint16_t)block[i];
302  int sign = val & 1;
303 
304  block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
305  + sign;
306  }
307 }
308 
309 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
310  const uint8_t *src, int src_size)
311 {
312  GetBitContext gb;
313  int ret, i, mb, blk;
314  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
315  int last_row = mb_y && mb_y == ctx->mb_height - 1;
316  int y_pos, c_pos;
317  uint8_t *Y, *C[2];
318  uint8_t *dst;
319  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
320  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
321  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
322  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
323  const int ystride = ctx->frame->linesize[0];
324 
325  if (last_row) {
326  y_pos = (ctx->avctx->height - 16);
327  c_pos = ((ctx->avctx->height+1)/2 - 8);
328  } else {
329  y_pos = mb_y * 16;
330  c_pos = mb_y * 8;
331  }
332 
333  Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
334  for (i = 0; i < 2; i++)
335  C[i] = ctx->frame->data[i + 1] + mb_x * 8
336  + c_pos * ctx->frame->linesize[i + 1];
337  init_get_bits(&gb, src, src_size * 8);
338 
339  memset(ctx->slice_data, 0,
340  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
341  for (i = 0; i < NUM_BANDS; i++)
342  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
343  i, slice_width,
344  !ctx->interlaced)) < 0)
345  return ret;
346 
347  for (mb = 0; mb < slice_width; mb++) {
348  for (blk = 0; blk < 4; blk++) {
349  if (!ctx->interlaced)
350  recombine_block(ctx->block, ctx->idsp.idct_permutation,
351  &base_y, &ext_y);
352  else
353  recombine_block_il(ctx->block, ctx->idsp.idct_permutation,
354  &base_y, &ext_y, blk);
355  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
356  ctx->idsp.idct(ctx->block);
357 
358  if (!ctx->interlaced) {
359  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
360  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
361  } else {
362  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
363  ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
364  ystride * 2);
365  }
366  }
367  Y += 16;
368 
369  for (blk = 0; blk < 2; blk++) {
370  recombine_block(ctx->block, ctx->idsp.idct_permutation,
371  &base_c, &ext_c);
372  unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
373  ctx->idsp.idct(ctx->block);
374  ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
375  ctx->frame->linesize[blk + 1]);
376  C[blk] += 8;
377  }
378  }
379 
380  return 0;
381 }
382 
384  int *got_frame, AVPacket *avpkt)
385 {
386  AICContext *ctx = avctx->priv_data;
387  const uint8_t *buf = avpkt->data;
388  int buf_size = avpkt->size;
389  GetByteContext gb;
390  uint32_t off;
391  int x, y, ret;
392  int slice_size;
393 
394  ctx->frame = frame;
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, ctx->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 
447  ctx->avctx = avctx;
448 
449  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
450 
451  ff_idctdsp_init(&ctx->idsp, avctx);
452 
453  for (i = 0; i < 64; i++)
454  ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
455 
456  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
457  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
458 
459  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
460  ctx->slice_width = 16;
461  for (i = 1; i < ctx->mb_width; i++) {
462  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
463  ctx->slice_width = ctx->mb_width / i;
464  ctx->num_x_slices = i;
465  break;
466  }
467  }
468 
469  ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
470  * sizeof(*ctx->slice_data));
471  if (!ctx->slice_data) {
472  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
473 
474  return AVERROR(ENOMEM);
475  }
476 
477  for (i = 0; i < NUM_BANDS; i++)
478  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
479  * aic_band_off[i];
480 
481  return 0;
482 }
483 
485 {
486  AICContext *ctx = avctx->priv_data;
487 
488  av_freep(&ctx->slice_data);
489 
490  return 0;
491 }
492 
494  .p.name = "aic",
495  CODEC_LONG_NAME("Apple Intermediate Codec"),
496  .p.type = AVMEDIA_TYPE_VIDEO,
497  .p.id = AV_CODEC_ID_AIC,
498  .priv_data_size = sizeof(AICContext),
500  .close = aic_decode_close,
502  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
503 };
AIC_HDR_SIZE
#define AIC_HDR_SIZE
Definition: aic.c:36
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
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:296
aic_c_scan
static const uint8_t aic_c_scan[64]
Definition: aic.c:100
AICContext::block
int16_t block[64]
Definition: aic.c:156
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVPacket::data
uint8_t * data
Definition: packet.h:374
recombine_block
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:254
FFCodec
Definition: codec_internal.h:119
base
uint8_t base
Definition: vp3data.h:128
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
thread.h
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
AICContext::frame
AVFrame * frame
Definition: aic.c:144
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:39
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
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:43
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AICContext::mb_height
int mb_height
Definition: aic.c:149
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:149
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:203
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
frame_size
int frame_size
Definition: mxfenc.c:2202
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
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:186
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:154
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
ff_aic_decoder
const FFCodec ff_aic_decoder
Definition: aic.c:493
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
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:375
codec_internal.h
aic_decode_frame
static int aic_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: aic.c:383
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
mb
#define mb
Definition: vf_colormatrix.c:101
unary.h
Y
#define Y
Definition: boxblur.h:37
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:153
AICContext::avctx
AVCodecContext * avctx
Definition: aic.c:143
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: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:160
AIC_BAND_COEFFS
#define AIC_BAND_COEFFS
Definition: aic.c:37
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
GET_CODE
#define GET_CODE(val, type, add_bits)
Definition: aic.c:193
AICContext::num_x_slices
int num_x_slices
Definition: aic.c:147
aic_c_ext_scan
static const uint8_t aic_c_ext_scan[192]
Definition: aic.c:111
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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:484
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:221
IDCTDSPContext
Definition: idctdsp.h:44
aic_quant_matrix
static const uint8_t aic_quant_matrix[64]
Definition: aic.c:51
AICContext::interlaced
int interlaced
Definition: aic.c:151
COEFF_CHROMA
@ COEFF_CHROMA
Definition: aic.c:41
AVCodecContext
main external API structure.
Definition: avcodec.h:398
aic_band_off
static const uint16_t aic_band_off[NUM_BANDS]
Definition: aic.c:49
AICContext::quant
int quant
Definition: aic.c:150
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
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:274
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:27
AICContext
Definition: aic.c:142
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AICContext::quant_matrix
uint8_t quant_matrix[64]
Definition: aic.c:157
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:309
COEFF_LUMA_EXT
@ COEFF_LUMA_EXT
Definition: aic.c:42
AICContext::slice_width
int slice_width
Definition: aic.c:148
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