2 * Apple Intermediate Codec decoder
4 * Copyright (c) 2013 Konstantin Shishkov
6 * This file is part of Libav.
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.
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.
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
24 #include "bytestream.h"
31 #define AIC_HDR_SIZE 24
32 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
42 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
44 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
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,
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,
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,
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,
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,
133 static const uint8_t *aic_scan[NUM_BANDS] = {
134 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
137 typedef struct AICContext {
138 AVCodecContext *avctx;
145 int mb_width, mb_height;
150 int16_t *data_ptr[NUM_BANDS];
152 DECLARE_ALIGNED(16, int16_t, block)[64];
155 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
161 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
162 return AVERROR_INVALIDDATA;
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;
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",
174 return AVERROR_INVALIDDATA;
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;
182 ctx->quant = src[15];
183 ctx->interlaced = ((src[16] >> 4) == 3);
188 #define GET_CODE(val, type, add_bits) \
191 val = get_ue_golomb(gb); \
193 val = get_unary(gb, 1, 31); \
195 val = (val << add_bits) + get_bits(gb, add_bits); \
198 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
199 int band, int slice_width, int force_chroma)
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];
206 has_skips = get_bits1(gb);
207 coeff_type = get_bits1(gb);
208 coeff_bits = get_bits(gb, 3);
211 skip_type = get_bits1(gb);
212 skip_bits = get_bits(gb, 3);
214 for (mb = 0; mb < slice_width; mb++) {
217 GET_CODE(val, skip_type, skip_bits);
219 return AVERROR_INVALIDDATA;
221 if (idx >= num_coeffs)
223 GET_CODE(val, coeff_type, coeff_bits);
225 if (val >= 0x10000 || val < 0)
226 return AVERROR_INVALIDDATA;
227 dst[scan[idx]] = val;
228 } while (idx < num_coeffs - 1);
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;
245 static void recombine_block(int16_t *dst, const uint8_t *scan,
246 int16_t **base, int16_t **ext)
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];
259 for (j = 0; j < 8; j++)
260 dst[scan[i * 8 + j]] = (*ext)[j];
265 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
266 int16_t **base, int16_t **ext,
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];
281 for (i = 0; i < 64; i++)
282 dst[scan[i]] = (*ext)[i];
287 static void unquant_block(int16_t *block, int q)
291 for (i = 0; i < 64; i++) {
292 int val = (uint16_t)block[i];
295 block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
300 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
301 const uint8_t *src, int src_size)
305 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
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];
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);
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],
325 !ctx->interlaced)) < 0)
328 for (mb = 0; mb < slice_width; mb++) {
329 for (blk = 0; blk < 4; blk++) {
330 if (!ctx->interlaced)
331 recombine_block(ctx->block, ctx->scantable.permutated,
334 recombine_block_il(ctx->block, ctx->scantable.permutated,
335 &base_y, &ext_y, blk);
336 unquant_block(ctx->block, ctx->quant);
337 ctx->dsp.idct(ctx->block);
339 if (!ctx->interlaced) {
340 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
341 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
344 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
345 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
351 for (blk = 0; blk < 2; blk++) {
352 recombine_block(ctx->block, ctx->scantable.permutated,
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]);
365 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
368 AICContext *ctx = avctx->priv_data;
369 const uint8_t *buf = avpkt->data;
370 int buf_size = avpkt->size;
377 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
378 ctx->frame->key_frame = 1;
380 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
382 if (buf_size < off) {
383 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
384 return AVERROR_INVALIDDATA;
387 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
390 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
393 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
394 ctx->num_x_slices * ctx->mb_height * 2);
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;
404 if ((ret = aic_decode_slice(ctx, x, y,
405 buf + off, slice_size)) < 0)
417 static av_cold int aic_decode_init(AVCodecContext *avctx)
419 AICContext *ctx = avctx->priv_data;
425 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
427 ff_dsputil_init(&ctx->dsp, avctx);
429 for (i = 0; i < 64; i++)
431 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
433 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
434 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
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;
446 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
447 * sizeof(*ctx->slice_data));
448 if (!ctx->slice_data) {
449 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
451 return AVERROR(ENOMEM);
454 for (i = 0; i < NUM_BANDS; i++)
455 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
461 static av_cold int aic_decode_close(AVCodecContext *avctx)
463 AICContext *ctx = avctx->priv_data;
465 av_freep(&ctx->slice_data);
470 AVCodec ff_aic_decoder = {
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),
476 .init = aic_decode_init,
477 .close = aic_decode_close,
478 .decode = aic_decode_frame,
479 .capabilities = CODEC_CAP_DR1,