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.h"
26 #include "libavutil/mem_internal.h"
27 
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "codec_internal.h"
31 #include "get_bits.h"
32 #include "golomb.h"
33 #include "idctdsp.h"
34 #include "thread.h"
35 #include "unary.h"
36 
37 #define AIC_HDR_SIZE 24
38 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
39 
40 enum AICBands {
46 };
47 
48 static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
49 
50 static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
51 
52 static const uint8_t aic_quant_matrix[64] = {
53  8, 16, 19, 22, 22, 26, 26, 27,
54  16, 16, 22, 22, 26, 27, 27, 29,
55  19, 22, 26, 26, 27, 29, 29, 35,
56  22, 24, 27, 27, 29, 32, 34, 38,
57  26, 27, 29, 29, 32, 35, 38, 46,
58  27, 29, 34, 34, 35, 40, 46, 56,
59  29, 34, 34, 37, 40, 48, 56, 69,
60  34, 37, 38, 40, 48, 58, 69, 83,
61 };
62 
63 static const uint8_t aic_y_scan[64] = {
64  0, 4, 1, 2, 5, 8, 12, 9,
65  6, 3, 7, 10, 13, 14, 11, 15,
66  47, 43, 46, 45, 42, 39, 35, 38,
67  41, 44, 40, 37, 34, 33, 36, 32,
68  16, 20, 17, 18, 21, 24, 28, 25,
69  22, 19, 23, 26, 29, 30, 27, 31,
70  63, 59, 62, 61, 58, 55, 51, 54,
71  57, 60, 56, 53, 50, 49, 52, 48,
72 };
73 
74 static const uint8_t aic_y_ext_scan[192] = {
75  64, 72, 65, 66, 73, 80, 88, 81,
76  74, 67, 75, 82, 89, 90, 83, 91,
77  0, 4, 1, 2, 5, 8, 12, 9,
78  6, 3, 7, 10, 13, 14, 11, 15,
79  16, 20, 17, 18, 21, 24, 28, 25,
80  22, 19, 23, 26, 29, 30, 27, 31,
81  155, 147, 154, 153, 146, 139, 131, 138,
82  145, 152, 144, 137, 130, 129, 136, 128,
83  47, 43, 46, 45, 42, 39, 35, 38,
84  41, 44, 40, 37, 34, 33, 36, 32,
85  63, 59, 62, 61, 58, 55, 51, 54,
86  57, 60, 56, 53, 50, 49, 52, 48,
87  96, 104, 97, 98, 105, 112, 120, 113,
88  106, 99, 107, 114, 121, 122, 115, 123,
89  68, 76, 69, 70, 77, 84, 92, 85,
90  78, 71, 79, 86, 93, 94, 87, 95,
91  100, 108, 101, 102, 109, 116, 124, 117,
92  110, 103, 111, 118, 125, 126, 119, 127,
93  187, 179, 186, 185, 178, 171, 163, 170,
94  177, 184, 176, 169, 162, 161, 168, 160,
95  159, 151, 158, 157, 150, 143, 135, 142,
96  149, 156, 148, 141, 134, 133, 140, 132,
97  191, 183, 190, 189, 182, 175, 167, 174,
98  181, 188, 180, 173, 166, 165, 172, 164,
99 };
100 
101 static const uint8_t aic_c_scan[64] = {
102  0, 4, 1, 2, 5, 8, 12, 9,
103  6, 3, 7, 10, 13, 14, 11, 15,
104  31, 27, 30, 29, 26, 23, 19, 22,
105  25, 28, 24, 21, 18, 17, 20, 16,
106  32, 36, 33, 34, 37, 40, 44, 41,
107  38, 35, 39, 42, 45, 46, 43, 47,
108  63, 59, 62, 61, 58, 55, 51, 54,
109  57, 60, 56, 53, 50, 49, 52, 48,
110 };
111 
112 static const uint8_t aic_c_ext_scan[192] = {
113  16, 24, 17, 18, 25, 32, 40, 33,
114  26, 19, 27, 34, 41, 42, 35, 43,
115  0, 4, 1, 2, 5, 8, 12, 9,
116  6, 3, 7, 10, 13, 14, 11, 15,
117  20, 28, 21, 22, 29, 36, 44, 37,
118  30, 23, 31, 38, 45, 46, 39, 47,
119  95, 87, 94, 93, 86, 79, 71, 78,
120  85, 92, 84, 77, 70, 69, 76, 68,
121  63, 59, 62, 61, 58, 55, 51, 54,
122  57, 60, 56, 53, 50, 49, 52, 48,
123  91, 83, 90, 89, 82, 75, 67, 74,
124  81, 88, 80, 73, 66, 65, 72, 64,
125  112, 120, 113, 114, 121, 128, 136, 129,
126  122, 115, 123, 130, 137, 138, 131, 139,
127  96, 100, 97, 98, 101, 104, 108, 105,
128  102, 99, 103, 106, 109, 110, 107, 111,
129  116, 124, 117, 118, 125, 132, 140, 133,
130  126, 119, 127, 134, 141, 142, 135, 143,
131  191, 183, 190, 189, 182, 175, 167, 174,
132  181, 188, 180, 173, 166, 165, 172, 164,
133  159, 155, 158, 157, 154, 151, 147, 150,
134  153, 156, 152, 149, 146, 145, 148, 144,
135  187, 179, 186, 185, 178, 171, 163, 170,
136  177, 184, 176, 169, 162, 161, 168, 160,
137 };
138 
139 static const uint8_t * const aic_scan[NUM_BANDS] = {
141 };
142 
143 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->idsp.idct_permutation,
352  &base_y, &ext_y);
353  else
354  recombine_block_il(ctx->block, ctx->idsp.idct_permutation,
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->idsp.idct_permutation,
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 
385  int *got_frame, 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 
395  ctx->frame = frame;
396 
397  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
398 
399  if (buf_size < off) {
400  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
401  return AVERROR_INVALIDDATA;
402  }
403 
404  ret = aic_decode_header(ctx, buf, buf_size);
405  if (ret < 0) {
406  av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
407  return ret;
408  }
409 
410  if ((ret = ff_thread_get_buffer(avctx, ctx->frame, 0)) < 0)
411  return ret;
412 
413  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
414  ctx->num_x_slices * ctx->mb_height * 2);
415 
416  for (y = 0; y < ctx->mb_height; y++) {
417  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
418  slice_size = bytestream2_get_le16(&gb) * 4;
419  if (slice_size + off > buf_size || !slice_size) {
420  av_log(avctx, AV_LOG_ERROR,
421  "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
422  return AVERROR_INVALIDDATA;
423  }
424 
425  ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
426  if (ret < 0) {
427  av_log(avctx, AV_LOG_ERROR,
428  "Error decoding slice at %d.%d\n", x, y);
429  return ret;
430  }
431 
432  off += slice_size;
433  }
434  }
435 
436  *got_frame = 1;
437 
438  return avpkt->size;
439 }
440 
442 {
443  AICContext *ctx = avctx->priv_data;
444  int i;
445 
446  ctx->avctx = avctx;
447 
448  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
449 
450  ff_idctdsp_init(&ctx->idsp, avctx);
451 
452  for (i = 0; i < 64; i++)
453  ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
454 
455  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
456  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
457 
458  ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
459  ctx->slice_width = 16;
460  for (i = 1; i < ctx->mb_width; i++) {
461  if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
462  ctx->slice_width = ctx->mb_width / i;
463  ctx->num_x_slices = i;
464  break;
465  }
466  }
467 
468  ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
469  * sizeof(*ctx->slice_data));
470  if (!ctx->slice_data) {
471  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
472 
473  return AVERROR(ENOMEM);
474  }
475 
476  for (i = 0; i < NUM_BANDS; i++)
477  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
478  * aic_band_off[i];
479 
480  return 0;
481 }
482 
484 {
485  AICContext *ctx = avctx->priv_data;
486 
487  av_freep(&ctx->slice_data);
488 
489  return 0;
490 }
491 
493  .p.name = "aic",
494  CODEC_LONG_NAME("Apple Intermediate Codec"),
495  .p.type = AVMEDIA_TYPE_VIDEO,
496  .p.id = AV_CODEC_ID_AIC,
497  .priv_data_size = sizeof(AICContext),
499  .close = aic_decode_close,
501  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
502 };
AIC_HDR_SIZE
#define AIC_HDR_SIZE
Definition: aic.c:37
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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:101
AICContext::block
int16_t block[64]
Definition: aic.c:157
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:524
recombine_block
static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)
Definition: aic.c:255
FFCodec
Definition: codec_internal.h:126
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:514
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:145
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
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:335
AICBands
AICBands
Definition: aic.c:40
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
GetBitContext
Definition: get_bits.h:108
COEFF_CHROMA_EXT
@ COEFF_CHROMA_EXT
Definition: aic.c:44
val
static double val(void *priv, double ch)
Definition: aeval.c:78
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
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
frame_size
int frame_size
Definition: mxfenc.c:2423
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:986
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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:73
blk
#define blk(i)
Definition: sha.c:186
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
aic_y_ext_scan
static const uint8_t aic_y_ext_scan[192]
Definition: aic.c:74
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:110
ff_aic_decoder
const FFCodec ff_aic_decoder
Definition: aic.c:492
aic_decode_init
static av_cold int aic_decode_init(AVCodecContext *avctx)
Definition: aic.c:441
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
COEFF_LUMA
@ COEFF_LUMA
Definition: aic.c:41
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
aic_decode_frame
static int aic_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: aic.c:384
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:99
unary.h
Y
#define Y
Definition: boxblur.h:37
NUM_BANDS
@ NUM_BANDS
Definition: aic.c:45
AICContext::slice_data
int16_t * slice_data
Definition: aic.c:154
AICContext::avctx
AVCodecContext * avctx
Definition: aic.c:144
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
aic_y_scan
static const uint8_t aic_y_scan[64]
Definition: aic.c:63
aic_scan
static const uint8_t *const aic_scan[NUM_BANDS]
Definition: aic.c:139
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:38
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:194
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:112
AVCodecContext::height
int height
Definition: avcodec.h:618
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
idctdsp.h
avcodec.h
aic_num_band_coeffs
static const uint8_t aic_num_band_coeffs[NUM_BANDS]
Definition: aic.c:48
aic_decode_close
static av_cold int aic_decode_close(AVCodecContext *avctx)
Definition: aic.c:483
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:43
aic_quant_matrix
static const uint8_t aic_quant_matrix[64]
Definition: aic.c:52
AICContext::interlaced
int interlaced
Definition: aic.c:152
COEFF_CHROMA
@ COEFF_CHROMA
Definition: aic.c:42
AVCodecContext
main external API structure.
Definition: avcodec.h:445
aic_band_off
static const uint16_t aic_band_off[NUM_BANDS]
Definition: aic.c:50
AICContext::quant
int quant
Definition: aic.c:151
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
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:143
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: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:43
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:146