Libav
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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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, val;
205 
206  has_skips = get_bits1(gb);
207  coeff_type = get_bits1(gb);
208  coeff_bits = get_bits(gb, 3);
209 
210  if (has_skips) {
211  skip_type = get_bits1(gb);
212  skip_bits = get_bits(gb, 3);
213 
214  for (mb = 0; mb < slice_width; mb++) {
215  idx = -1;
216  do {
217  GET_CODE(val, skip_type, skip_bits);
218  if (val < 0)
219  return AVERROR_INVALIDDATA;
220  idx += val + 1;
221  if (idx >= num_coeffs)
222  break;
223  GET_CODE(val, coeff_type, coeff_bits);
224  val++;
225  if (val >= 0x10000 || val < 0)
226  return AVERROR_INVALIDDATA;
227  dst[scan[idx]] = val;
228  } while (idx < num_coeffs - 1);
229  dst += num_coeffs;
230  }
231  } else {
232  for (mb = 0; mb < slice_width; mb++) {
233  for (idx = 0; idx < num_coeffs; idx++) {
234  GET_CODE(val, coeff_type, coeff_bits);
235  if (val >= 0x10000 || val < 0)
236  return AVERROR_INVALIDDATA;
237  dst[scan[idx]] = val;
238  }
239  dst += num_coeffs;
240  }
241  }
242  return 0;
243 }
244 
245 static void recombine_block(int16_t *dst, const uint8_t *scan,
246  int16_t **base, int16_t **ext)
247 {
248  int i, j;
249 
250  for (i = 0; i < 4; i++) {
251  for (j = 0; j < 4; j++)
252  dst[scan[i * 8 + j]] = (*base)[j];
253  for (j = 0; j < 4; j++)
254  dst[scan[i * 8 + j + 4]] = (*ext)[j];
255  *base += 4;
256  *ext += 4;
257  }
258  for (; i < 8; i++) {
259  for (j = 0; j < 8; j++)
260  dst[scan[i * 8 + j]] = (*ext)[j];
261  *ext += 8;
262  }
263 }
264 
265 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
266  int16_t **base, int16_t **ext,
267  int block_no)
268 {
269  int i, j;
270 
271  if (block_no < 2) {
272  for (i = 0; i < 8; i++) {
273  for (j = 0; j < 4; j++)
274  dst[scan[i * 8 + j]] = (*base)[j];
275  for (j = 0; j < 4; j++)
276  dst[scan[i * 8 + j + 4]] = (*ext)[j];
277  *base += 4;
278  *ext += 4;
279  }
280  } else {
281  for (i = 0; i < 64; i++)
282  dst[scan[i]] = (*ext)[i];
283  *ext += 64;
284  }
285 }
286 
287 static void unquant_block(int16_t *block, int q)
288 {
289  int i;
290 
291  for (i = 0; i < 64; i++) {
292  int val = (uint16_t)block[i];
293  int sign = val & 1;
294 
295  block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
296  + sign;
297  }
298 }
299 
300 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
301  const uint8_t *src, int src_size)
302 {
303  GetBitContext gb;
304  int ret, i, mb, blk;
305  int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
306  uint8_t *Y, *C[2];
307  uint8_t *dst;
308  int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
309  int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
310  int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
311  int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
312  const int ystride = ctx->frame->linesize[0];
313 
314  Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
315  for (i = 0; i < 2; i++)
316  C[i] = ctx->frame->data[i + 1] + mb_x * 8
317  + mb_y * 8 * ctx->frame->linesize[i + 1];
318  init_get_bits(&gb, src, src_size * 8);
319 
320  memset(ctx->slice_data, 0,
321  sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
322  for (i = 0; i < NUM_BANDS; i++)
323  if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
324  i, slice_width,
325  !ctx->interlaced)) < 0)
326  return ret;
327 
328  for (mb = 0; mb < slice_width; mb++) {
329  for (blk = 0; blk < 4; blk++) {
330  if (!ctx->interlaced)
332  &base_y, &ext_y);
333  else
335  &base_y, &ext_y, blk);
336  unquant_block(ctx->block, ctx->quant);
337  ctx->dsp.idct(ctx->block);
338 
339  if (!ctx->interlaced) {
340  dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
341  ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
342  ystride);
343  } else {
344  dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
345  ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
346  ystride * 2);
347  }
348  }
349  Y += 16;
350 
351  for (blk = 0; blk < 2; blk++) {
353  &base_c, &ext_c);
354  unquant_block(ctx->block, ctx->quant);
355  ctx->dsp.idct(ctx->block);
356  ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
357  ctx->frame->linesize[blk + 1]);
358  C[blk] += 8;
359  }
360  }
361 
362  return 0;
363 }
364 
365 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
366  AVPacket *avpkt)
367 {
368  AICContext *ctx = avctx->priv_data;
369  const uint8_t *buf = avpkt->data;
370  int buf_size = avpkt->size;
371  GetByteContext gb;
372  uint32_t off;
373  int x, y, ret;
374  int slice_size;
375 
376  ctx->frame = data;
378  ctx->frame->key_frame = 1;
379 
380  off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
381 
382  if (buf_size < off) {
383  av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
384  return AVERROR_INVALIDDATA;
385  }
386 
387  if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
388  return ret;
389 
390  if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
391  return ret;
392 
393  bytestream2_init(&gb, buf + AIC_HDR_SIZE,
394  ctx->num_x_slices * ctx->mb_height * 2);
395 
396  for (y = 0; y < ctx->mb_height; y++) {
397  for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
398  slice_size = bytestream2_get_le16(&gb) * 4;
399  if (slice_size + off > buf_size || !slice_size) {
400  av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
401  return AVERROR_INVALIDDATA;
402  }
403 
404  if ((ret = aic_decode_slice(ctx, x, y,
405  buf + off, slice_size)) < 0)
406  return ret;
407 
408  off += slice_size;
409  }
410  }
411 
412  *got_frame = 1;
413 
414  return avpkt->size;
415 }
416 
418 {
419  AICContext *ctx = avctx->priv_data;
420  int i;
421  uint8_t scan[64];
422 
423  ctx->avctx = avctx;
424 
425  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
426 
427  ff_dsputil_init(&ctx->dsp, avctx);
428 
429  for (i = 0; i < 64; i++)
430  scan[i] = i;
431  ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
432 
433  ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
434  ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
435 
436  ctx->num_x_slices = 16;
437  ctx->slice_width = ctx->mb_width / 16;
438  for (i = 1; i < 32; i++) {
439  if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
440  ctx->slice_width = ctx->mb_width / i;
441  ctx->num_x_slices = i;
442  break;
443  }
444  }
445 
447  * sizeof(*ctx->slice_data));
448  if (!ctx->slice_data) {
449  av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
450 
451  return AVERROR(ENOMEM);
452  }
453 
454  for (i = 0; i < NUM_BANDS; i++)
455  ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
456  * aic_band_off[i];
457 
458  return 0;
459 }
460 
462 {
463  AICContext *ctx = avctx->priv_data;
464 
465  av_freep(&ctx->slice_data);
466 
467  return 0;
468 }
469 
471  .name = "aic",
472  .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
473  .type = AVMEDIA_TYPE_VIDEO,
474  .id = AV_CODEC_ID_AIC,
475  .priv_data_size = sizeof(AICContext),
479  .capabilities = CODEC_CAP_DR1,
480 };