FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
aic.c
Go to the documentation of this file.
1 /*
2  * Apple Intermediate Codec decoder
3  *
4  * Copyright (c) 2013 Konstantin Shishkov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "avcodec.h"
24 #include "bytestream.h"
25 #include "dsputil.h"
26 #include "internal.h"
27 #include "get_bits.h"
28 #include "golomb.h"
29 #include "unary.h"
30 
31 #define AIC_HDR_SIZE 24
32 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
33 
34 enum AICBands {
40 };
41 
42 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
43 
44 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
45 
46 static const uint8_t aic_quant_matrix[64] = {
47  8, 16, 19, 22, 22, 26, 26, 27,
48  16, 16, 22, 22, 26, 27, 27, 29,
49  19, 22, 26, 26, 27, 29, 29, 35,
50  22, 24, 27, 27, 29, 32, 34, 38,
51  26, 27, 29, 29, 32, 35, 38, 46,
52  27, 29, 34, 34, 35, 40, 46, 56,
53  29, 34, 34, 37, 40, 48, 56, 69,
54  34, 37, 38, 40, 48, 58, 69, 83,
55 };
56 
57 static const uint8_t aic_y_scan[64] = {
58  0, 4, 1, 2, 5, 8, 12, 9,
59  6, 3, 7, 10, 13, 14, 11, 15,
60  47, 43, 46, 45, 42, 39, 35, 38,
61  41, 44, 40, 37, 34, 33, 36, 32,
62  16, 20, 17, 18, 21, 24, 28, 25,
63  22, 19, 23, 26, 29, 30, 27, 31,
64  63, 59, 62, 61, 58, 55, 51, 54,
65  57, 60, 56, 53, 50, 49, 52, 48,
66 };
67 
68 static const uint8_t aic_y_ext_scan[192] = {
69  64, 72, 65, 66, 73, 80, 88, 81,
70  74, 67, 75, 82, 89, 90, 83, 91,
71  0, 4, 1, 2, 5, 8, 12, 9,
72  6, 3, 7, 10, 13, 14, 11, 15,
73  16, 20, 17, 18, 21, 24, 28, 25,
74  22, 19, 23, 26, 29, 30, 27, 31,
75  155, 147, 154, 153, 146, 139, 131, 138,
76  145, 152, 144, 137, 130, 129, 136, 128,
77  47, 43, 46, 45, 42, 39, 35, 38,
78  41, 44, 40, 37, 34, 33, 36, 32,
79  63, 59, 62, 61, 58, 55, 51, 54,
80  57, 60, 56, 53, 50, 49, 52, 48,
81  96, 104, 97, 98, 105, 112, 120, 113,
82  106, 99, 107, 114, 121, 122, 115, 123,
83  68, 76, 69, 70, 77, 84, 92, 85,
84  78, 71, 79, 86, 93, 94, 87, 95,
85  100, 108, 101, 102, 109, 116, 124, 117,
86  110, 103, 111, 118, 125, 126, 119, 127,
87  187, 179, 186, 185, 178, 171, 163, 170,
88  177, 184, 176, 169, 162, 161, 168, 160,
89  159, 151, 158, 157, 150, 143, 135, 142,
90  149, 156, 148, 141, 134, 133, 140, 132,
91  191, 183, 190, 189, 182, 175, 167, 174,
92  181, 188, 180, 173, 166, 165, 172, 164,
93 };
94 
95 static const uint8_t aic_c_scan[64] = {
96  0, 4, 1, 2, 5, 8, 12, 9,
97  6, 3, 7, 10, 13, 14, 11, 15,
98  31, 27, 30, 29, 26, 23, 19, 22,
99  25, 28, 24, 21, 18, 17, 20, 16,
100  32, 36, 33, 34, 37, 40, 44, 41,
101  38, 35, 39, 42, 45, 46, 43, 47,
102  63, 59, 62, 61, 58, 55, 51, 54,
103  57, 60, 56, 53, 50, 49, 52, 48,
104 };
105 
106 static const uint8_t aic_c_ext_scan[192] = {
107  16, 24, 17, 18, 25, 32, 40, 33,
108  26, 19, 27, 34, 41, 42, 35, 43,
109  0, 4, 1, 2, 5, 8, 12, 9,
110  6, 3, 7, 10, 13, 14, 11, 15,
111  20, 28, 21, 22, 29, 36, 44, 37,
112  30, 23, 31, 38, 45, 46, 39, 47,
113  95, 87, 94, 93, 86, 79, 71, 78,
114  85, 92, 84, 77, 70, 69, 76, 68,
115  63, 59, 62, 61, 58, 55, 51, 54,
116  57, 60, 56, 53, 50, 49, 52, 48,
117  91, 83, 90, 89, 82, 75, 67, 74,
118  81, 88, 80, 73, 66, 65, 72, 64,
119  112, 120, 113, 114, 121, 128, 136, 129,
120  122, 115, 123, 130, 137, 138, 131, 139,
121  96, 100, 97, 98, 101, 104, 108, 105,
122  102, 99, 103, 106, 109, 110, 107, 111,
123  116, 124, 117, 118, 125, 132, 140, 133,
124  126, 119, 127, 134, 141, 142, 135, 143,
125  191, 183, 190, 189, 182, 175, 167, 174,
126  181, 188, 180, 173, 166, 165, 172, 164,
127  159, 155, 158, 157, 154, 151, 147, 150,
128  153, 156, 152, 149, 146, 145, 148, 144,
129  187, 179, 186, 185, 178, 171, 163, 170,
130  177, 184, 176, 169, 162, 161, 168, 160,
131 };
132 
133 static const uint8_t *aic_scan[NUM_BANDS] = {
135 };
136 
137 typedef struct AICContext {
142 
146  int quant;
148 
149  int16_t *slice_data;
150  int16_t *data_ptr[NUM_BANDS];
151 
152  DECLARE_ALIGNED(16, int16_t, block)[64];
153 } AICContext;
154 
155 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
156 {
157  uint32_t frame_size;
158  int width, height;
159 
160  if (src[0] != 1) {
161  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
162  return AVERROR_INVALIDDATA;
163  }
164  if (src[1] != AIC_HDR_SIZE - 2) {
165  av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
166  return AVERROR_INVALIDDATA;
167  }
168  frame_size = AV_RB32(src + 2);
169  width = AV_RB16(src + 6);
170  height = AV_RB16(src + 8);
171  if (frame_size > size) {
172  av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %d got %d\n",
173  frame_size, size);
174  return AVERROR_INVALIDDATA;
175  }
176  if (width != ctx->avctx->width || height != ctx->avctx->height) {
177  av_log(ctx->avctx, AV_LOG_ERROR,
178  "Picture dimension changed: old: %d x %d, new: %d x %d\n",
179  ctx->avctx->width, ctx->avctx->height, width, height);
180  return AVERROR_INVALIDDATA;
181  }
182  ctx->quant = src[15];
183  ctx->interlaced = ((src[16] >> 4) == 3);
184 
185  return 0;
186 }
187 
188 #define GET_CODE(val, type, add_bits) \
189  do { \
190  if (type) \
191  val = get_ue_golomb(gb); \
192  else \
193  val = get_unary(gb, 1, 31); \
194  if (add_bits) \
195  val = (val << add_bits) + get_bits(gb, add_bits); \
196  } while (0)
197 
198 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
199  int band, int slice_width, int force_chroma)
200 {
201  int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
202  const int num_coeffs = aic_num_band_coeffs[band];
203  const uint8_t *scan = aic_scan[band | force_chroma];
204  int mb, idx;
205  unsigned val;
206 
207  has_skips = get_bits1(gb);
208  coeff_type = get_bits1(gb);
209  coeff_bits = get_bits(gb, 3);
210 
211  if (has_skips) {
212  skip_type = get_bits1(gb);
213  skip_bits = get_bits(gb, 3);
214 
215  for (mb = 0; mb < slice_width; mb++) {
216  idx = -1;
217  do {
218  GET_CODE(val, skip_type, skip_bits);
219  if (val >= 0x10000)
220  return AVERROR_INVALIDDATA;
221  idx += val + 1;
222  if (idx >= num_coeffs)
223  break;
224  GET_CODE(val, coeff_type, coeff_bits);
225  val++;
226  if (val >= 0x10000)
227  return AVERROR_INVALIDDATA;
228  dst[scan[idx]] = val;
229  } while (idx < num_coeffs - 1);
230  dst += num_coeffs;
231  }
232  } else {
233  for (mb = 0; mb < slice_width; mb++) {
234  for (idx = 0; idx < num_coeffs; idx++) {
235  GET_CODE(val, coeff_type, coeff_bits);
236  if (val >= 0x10000)
237  return AVERROR_INVALIDDATA;
238  dst[scan[idx]] = val;
239  }
240  dst += num_coeffs;
241  }
242  }
243  return 0;
244 }
245 
246 static void recombine_block(int16_t *dst, const uint8_t *scan,
247  int16_t **base, int16_t **ext)
248 {
249  int i, j;
250 
251  for (i = 0; i < 4; i++) {
252  for (j = 0; j < 4; j++)
253  dst[scan[i * 8 + j]] = (*base)[j];
254  for (j = 0; j < 4; j++)
255  dst[scan[i * 8 + j + 4]] = (*ext)[j];
256  *base += 4;
257  *ext += 4;
258  }
259  for (; i < 8; i++) {
260  for (j = 0; j < 8; j++)
261  dst[scan[i * 8 + j]] = (*ext)[j];
262  *ext += 8;
263  }
264 }
265 
266 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
267  int16_t **base, int16_t **ext,
268  int block_no)
269 {
270  int i, j;
271 
272  if (block_no < 2) {
273  for (i = 0; i < 8; i++) {
274  for (j = 0; j < 4; j++)
275  dst[scan[i * 8 + j]] = (*base)[j];
276  for (j = 0; j < 4; j++)
277  dst[scan[i * 8 + j + 4]] = (*ext)[j];
278  *base += 4;
279  *ext += 4;
280  }
281  } else {
282  for (i = 0; i < 64; i++)
283  dst[scan[i]] = (*ext)[i];
284  *ext += 64;
285  }
286 }
287 
288 static void unquant_block(int16_t *block, int q)
289 {
290  int i;
291 
292  for (i = 0; i < 64; i++) {
293  int val = (uint16_t)block[i];
294  int sign = val & 1;
295 
296  block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
297  + sign;
298  }
299 }
300 
301 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
302  const uint8_t *src, int src_size)
303 {
304  GetBitContext gb;
305  int ret, i, mb, blk;
306  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
307  uint8_t *Y, *C[2];
308  uint8_t *dst;
309  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
310  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
311  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
312  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
313  const int ystride = ctx->frame->linesize[0];
314 
315  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
316  for (i = 0; i < 2; i++)
317  C[i] = ctx->frame->data[i + 1] + mb_x * 8
318  + mb_y * 8 * ctx->frame->linesize[i + 1];
319  init_get_bits(&gb, src, src_size * 8);
320 
321  memset(ctx->slice_data, 0,
322  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
323  for (i = 0; i < NUM_BANDS; i++)
324  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
325  i, slice_width,
326  !ctx->interlaced)) < 0)
327  return ret;
328 
329  for (mb = 0; mb < slice_width; mb++) {
330  for (blk = 0; blk < 4; blk++) {
331  if (!ctx->interlaced)
333  &base_y, &ext_y);
334  else
336  &base_y, &ext_y, blk);
337  unquant_block(ctx->block, ctx->quant);
338  ctx->dsp.idct(ctx->block);
339 
340  if (!ctx->interlaced) {
341  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
342  ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
343  ystride);
344  } else {
345  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
346  ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
347  ystride * 2);
348  }
349  }
350  Y += 16;
351 
352  for (blk = 0; blk < 2; blk++) {
354  &base_c, &ext_c);
355  unquant_block(ctx->block, ctx->quant);
356  ctx->dsp.idct(ctx->block);
357  ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
358  ctx->frame->linesize[blk + 1]);
359  C[blk] += 8;
360  }
361  }
362 
363  return 0;
364 }
365 
366 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
367  AVPacket *avpkt)
368 {
369  AICContext *ctx = avctx->priv_data;
370  const uint8_t *buf = avpkt->data;
371  int buf_size = avpkt->size;
372  GetByteContext gb;
373  uint32_t off;
374  int x, y, ret;
375  int slice_size;
376 
377  ctx->frame = data;
379  ctx->frame->key_frame = 1;
380 
381  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
382 
383  if (buf_size < off) {
384  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
385  return AVERROR_INVALIDDATA;
386  }
387 
388  if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
389  return ret;
390 
391  if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
392  return ret;
393 
394  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
395  ctx->num_x_slices * ctx->mb_height * 2);
396 
397  for (y = 0; y < ctx->mb_height; y++) {
398  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
399  slice_size = bytestream2_get_le16(&gb) * 4;
400  if (slice_size + off > buf_size || !slice_size) {
401  av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
402  return AVERROR_INVALIDDATA;
403  }
404 
405  if ((ret = aic_decode_slice(ctx, x, y,
406  buf + off, slice_size)) < 0)
407  return ret;
408 
409  off += slice_size;
410  }
411  }
412 
413  *got_frame = 1;
414 
415  return avpkt->size;
416 }
417 
419 {
420  AICContext *ctx = avctx->priv_data;
421  int i;
422  uint8_t scan[64];
423 
424  ctx->avctx = avctx;
425 
426  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
427 
428  ff_dsputil_init(&ctx->dsp, avctx);
429 
430  for (i = 0; i < 64; i++)
431  scan[i] = i;
432  ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
433 
434  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
435  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
436 
437  ctx->num_x_slices = 16;
438  ctx->slice_width = ctx->mb_width / 16;
439  for (i = 1; i < 32; i++) {
440  if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
441  ctx->slice_width = ctx->mb_width / i;
442  ctx->num_x_slices = i;
443  break;
444  }
445  }
446 
448  * sizeof(*ctx->slice_data));
449  if (!ctx->slice_data) {
450  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
451 
452  return AVERROR(ENOMEM);
453  }
454 
455  for (i = 0; i < NUM_BANDS; i++)
456  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
457  * aic_band_off[i];
458 
459  return 0;
460 }
461 
463 {
464  AICContext *ctx = avctx->priv_data;
465 
466  av_freep(&ctx->slice_data);
467 
468  return 0;
469 }
470 
472  .name = "aic",
473  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
474  .type = AVMEDIA_TYPE_VIDEO,
475  .id = AV_CODEC_ID_AIC,
476  .priv_data_size = sizeof(AICContext),
480  .capabilities = CODEC_CAP_DR1,
481 };