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
26 #include "bytestream.h"
33 #define AIC_HDR_SIZE 24
34 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
44 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
48 static const uint8_t aic_quant_matrix[64] = {
49 8, 16, 19, 22, 22, 26, 26, 27,
50 16, 16, 22, 22, 26, 27, 27, 29,
51 19, 22, 26, 26, 27, 29, 29, 35,
52 22, 24, 27, 27, 29, 32, 34, 38,
53 26, 27, 29, 29, 32, 35, 38, 46,
54 27, 29, 34, 34, 35, 40, 46, 56,
55 29, 34, 34, 37, 40, 48, 56, 69,
56 34, 37, 38, 40, 48, 58, 69, 83,
59 static const uint8_t aic_y_scan[64] = {
60 0, 4, 1, 2, 5, 8, 12, 9,
61 6, 3, 7, 10, 13, 14, 11, 15,
62 47, 43, 46, 45, 42, 39, 35, 38,
63 41, 44, 40, 37, 34, 33, 36, 32,
64 16, 20, 17, 18, 21, 24, 28, 25,
65 22, 19, 23, 26, 29, 30, 27, 31,
66 63, 59, 62, 61, 58, 55, 51, 54,
67 57, 60, 56, 53, 50, 49, 52, 48,
70 static const uint8_t aic_y_ext_scan[192] = {
71 64, 72, 65, 66, 73, 80, 88, 81,
72 74, 67, 75, 82, 89, 90, 83, 91,
73 0, 4, 1, 2, 5, 8, 12, 9,
74 6, 3, 7, 10, 13, 14, 11, 15,
75 16, 20, 17, 18, 21, 24, 28, 25,
76 22, 19, 23, 26, 29, 30, 27, 31,
77 155, 147, 154, 153, 146, 139, 131, 138,
78 145, 152, 144, 137, 130, 129, 136, 128,
79 47, 43, 46, 45, 42, 39, 35, 38,
80 41, 44, 40, 37, 34, 33, 36, 32,
81 63, 59, 62, 61, 58, 55, 51, 54,
82 57, 60, 56, 53, 50, 49, 52, 48,
83 96, 104, 97, 98, 105, 112, 120, 113,
84 106, 99, 107, 114, 121, 122, 115, 123,
85 68, 76, 69, 70, 77, 84, 92, 85,
86 78, 71, 79, 86, 93, 94, 87, 95,
87 100, 108, 101, 102, 109, 116, 124, 117,
88 110, 103, 111, 118, 125, 126, 119, 127,
89 187, 179, 186, 185, 178, 171, 163, 170,
90 177, 184, 176, 169, 162, 161, 168, 160,
91 159, 151, 158, 157, 150, 143, 135, 142,
92 149, 156, 148, 141, 134, 133, 140, 132,
93 191, 183, 190, 189, 182, 175, 167, 174,
94 181, 188, 180, 173, 166, 165, 172, 164,
97 static const uint8_t aic_c_scan[64] = {
98 0, 4, 1, 2, 5, 8, 12, 9,
99 6, 3, 7, 10, 13, 14, 11, 15,
100 31, 27, 30, 29, 26, 23, 19, 22,
101 25, 28, 24, 21, 18, 17, 20, 16,
102 32, 36, 33, 34, 37, 40, 44, 41,
103 38, 35, 39, 42, 45, 46, 43, 47,
104 63, 59, 62, 61, 58, 55, 51, 54,
105 57, 60, 56, 53, 50, 49, 52, 48,
108 static const uint8_t aic_c_ext_scan[192] = {
109 16, 24, 17, 18, 25, 32, 40, 33,
110 26, 19, 27, 34, 41, 42, 35, 43,
111 0, 4, 1, 2, 5, 8, 12, 9,
112 6, 3, 7, 10, 13, 14, 11, 15,
113 20, 28, 21, 22, 29, 36, 44, 37,
114 30, 23, 31, 38, 45, 46, 39, 47,
115 95, 87, 94, 93, 86, 79, 71, 78,
116 85, 92, 84, 77, 70, 69, 76, 68,
117 63, 59, 62, 61, 58, 55, 51, 54,
118 57, 60, 56, 53, 50, 49, 52, 48,
119 91, 83, 90, 89, 82, 75, 67, 74,
120 81, 88, 80, 73, 66, 65, 72, 64,
121 112, 120, 113, 114, 121, 128, 136, 129,
122 122, 115, 123, 130, 137, 138, 131, 139,
123 96, 100, 97, 98, 101, 104, 108, 105,
124 102, 99, 103, 106, 109, 110, 107, 111,
125 116, 124, 117, 118, 125, 132, 140, 133,
126 126, 119, 127, 134, 141, 142, 135, 143,
127 191, 183, 190, 189, 182, 175, 167, 174,
128 181, 188, 180, 173, 166, 165, 172, 164,
129 159, 155, 158, 157, 154, 151, 147, 150,
130 153, 156, 152, 149, 146, 145, 148, 144,
131 187, 179, 186, 185, 178, 171, 163, 170,
132 177, 184, 176, 169, 162, 161, 168, 160,
135 static const uint8_t *aic_scan[NUM_BANDS] = {
136 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
139 typedef struct AICContext {
140 AVCodecContext *avctx;
147 int mb_width, mb_height;
152 int16_t *data_ptr[NUM_BANDS];
154 DECLARE_ALIGNED(16, int16_t, block)[64];
157 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
163 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
164 return AVERROR_INVALIDDATA;
166 if (src[1] != AIC_HDR_SIZE - 2) {
167 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
168 return AVERROR_INVALIDDATA;
170 frame_size = AV_RB32(src + 2);
171 width = AV_RB16(src + 6);
172 height = AV_RB16(src + 8);
173 if (frame_size > size) {
174 av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
176 return AVERROR_INVALIDDATA;
178 if (width != ctx->avctx->width || height != ctx->avctx->height) {
179 av_log(ctx->avctx, AV_LOG_ERROR,
180 "Picture dimension changed: old: %d x %d, new: %d x %d\n",
181 ctx->avctx->width, ctx->avctx->height, width, height);
182 return AVERROR_INVALIDDATA;
184 ctx->quant = src[15];
185 ctx->interlaced = ((src[16] >> 4) == 3);
190 #define GET_CODE(val, type, add_bits) \
193 val = get_ue_golomb(gb); \
195 val = get_unary(gb, 1, 31); \
197 val = (val << add_bits) + get_bits(gb, add_bits); \
200 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
201 int band, int slice_width, int force_chroma)
203 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
204 const int num_coeffs = aic_num_band_coeffs[band];
205 const uint8_t *scan = aic_scan[band | force_chroma];
208 has_skips = get_bits1(gb);
209 coeff_type = get_bits1(gb);
210 coeff_bits = get_bits(gb, 3);
213 skip_type = get_bits1(gb);
214 skip_bits = get_bits(gb, 3);
216 for (mb = 0; mb < slice_width; mb++) {
219 GET_CODE(val, skip_type, skip_bits);
221 return AVERROR_INVALIDDATA;
223 if (idx >= num_coeffs)
225 GET_CODE(val, coeff_type, coeff_bits);
227 if (val >= 0x10000 || val < 0)
228 return AVERROR_INVALIDDATA;
229 dst[scan[idx]] = val;
230 } while (idx < num_coeffs - 1);
234 for (mb = 0; mb < slice_width; mb++) {
235 for (idx = 0; idx < num_coeffs; idx++) {
236 GET_CODE(val, coeff_type, coeff_bits);
237 if (val >= 0x10000 || val < 0)
238 return AVERROR_INVALIDDATA;
239 dst[scan[idx]] = val;
247 static void recombine_block(int16_t *dst, const uint8_t *scan,
248 int16_t **base, int16_t **ext)
252 for (i = 0; i < 4; i++) {
253 for (j = 0; j < 4; j++)
254 dst[scan[i * 8 + j]] = (*base)[j];
255 for (j = 0; j < 4; j++)
256 dst[scan[i * 8 + j + 4]] = (*ext)[j];
261 for (j = 0; j < 8; j++)
262 dst[scan[i * 8 + j]] = (*ext)[j];
267 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
268 int16_t **base, int16_t **ext,
274 for (i = 0; i < 8; i++) {
275 for (j = 0; j < 4; j++)
276 dst[scan[i * 8 + j]] = (*base)[j];
277 for (j = 0; j < 4; j++)
278 dst[scan[i * 8 + j + 4]] = (*ext)[j];
283 for (i = 0; i < 64; i++)
284 dst[scan[i]] = (*ext)[i];
289 static void unquant_block(int16_t *block, int q)
293 for (i = 0; i < 64; i++) {
294 int val = (uint16_t)block[i];
297 block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
302 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
303 const uint8_t *src, int src_size)
307 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
310 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
311 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
312 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
313 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
314 const int ystride = ctx->frame->linesize[0];
316 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
317 for (i = 0; i < 2; i++)
318 C[i] = ctx->frame->data[i + 1] + mb_x * 8
319 + mb_y * 8 * ctx->frame->linesize[i + 1];
320 init_get_bits(&gb, src, src_size * 8);
322 memset(ctx->slice_data, 0,
323 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
324 for (i = 0; i < NUM_BANDS; i++)
325 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
327 !ctx->interlaced)) < 0)
330 for (mb = 0; mb < slice_width; mb++) {
331 for (blk = 0; blk < 4; blk++) {
332 if (!ctx->interlaced)
333 recombine_block(ctx->block, ctx->scantable.permutated,
336 recombine_block_il(ctx->block, ctx->scantable.permutated,
337 &base_y, &ext_y, blk);
338 unquant_block(ctx->block, ctx->quant);
339 ctx->idsp.idct(ctx->block);
341 if (!ctx->interlaced) {
342 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
343 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
345 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
346 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
352 for (blk = 0; blk < 2; blk++) {
353 recombine_block(ctx->block, ctx->scantable.permutated,
355 unquant_block(ctx->block, ctx->quant);
356 ctx->idsp.idct(ctx->block);
357 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
358 ctx->frame->linesize[blk + 1]);
366 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
369 AICContext *ctx = avctx->priv_data;
370 const uint8_t *buf = avpkt->data;
371 int buf_size = avpkt->size;
378 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
379 ctx->frame->key_frame = 1;
381 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
383 if (buf_size < off) {
384 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
385 return AVERROR_INVALIDDATA;
388 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
391 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
394 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
395 ctx->num_x_slices * ctx->mb_height * 2);
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;
405 if ((ret = aic_decode_slice(ctx, x, y,
406 buf + off, slice_size)) < 0)
418 static av_cold int aic_decode_init(AVCodecContext *avctx)
420 AICContext *ctx = avctx->priv_data;
426 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
428 ff_idctdsp_init(&ctx->idsp, avctx);
430 for (i = 0; i < 64; i++)
432 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
434 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
435 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
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;
447 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
448 * sizeof(*ctx->slice_data));
449 if (!ctx->slice_data) {
450 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
452 return AVERROR(ENOMEM);
455 for (i = 0; i < NUM_BANDS; i++)
456 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
462 static av_cold int aic_decode_close(AVCodecContext *avctx)
464 AICContext *ctx = avctx->priv_data;
466 av_freep(&ctx->slice_data);
471 AVCodec ff_aic_decoder = {
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),
477 .init = aic_decode_init,
478 .close = aic_decode_close,
479 .decode = aic_decode_frame,
480 .capabilities = CODEC_CAP_DR1,