2 * Apple Intermediate Codec decoder
4 * Copyright (c) 2013 Konstantin Shishkov
6 * This file is part of FFmpeg.
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.
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.
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
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];
209 has_skips = get_bits1(gb);
210 coeff_type = get_bits1(gb);
211 coeff_bits = get_bits(gb, 3);
214 skip_type = get_bits1(gb);
215 skip_bits = get_bits(gb, 3);
217 for (mb = 0; mb < slice_width; mb++) {
220 GET_CODE(val, skip_type, skip_bits);
222 return AVERROR_INVALIDDATA;
224 if (idx >= num_coeffs)
226 GET_CODE(val, coeff_type, coeff_bits);
229 return AVERROR_INVALIDDATA;
230 dst[scan[idx]] = val;
231 } while (idx < num_coeffs - 1);
235 for (mb = 0; mb < slice_width; mb++) {
236 for (idx = 0; idx < num_coeffs; idx++) {
237 GET_CODE(val, coeff_type, coeff_bits);
239 return AVERROR_INVALIDDATA;
240 dst[scan[idx]] = val;
248 static void recombine_block(int16_t *dst, const uint8_t *scan,
249 int16_t **base, int16_t **ext)
253 for (i = 0; i < 4; i++) {
254 for (j = 0; j < 4; j++)
255 dst[scan[i * 8 + j]] = (*base)[j];
256 for (j = 0; j < 4; j++)
257 dst[scan[i * 8 + j + 4]] = (*ext)[j];
262 for (j = 0; j < 8; j++)
263 dst[scan[i * 8 + j]] = (*ext)[j];
268 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
269 int16_t **base, int16_t **ext,
275 for (i = 0; i < 8; i++) {
276 for (j = 0; j < 4; j++)
277 dst[scan[i * 8 + j]] = (*base)[j];
278 for (j = 0; j < 4; j++)
279 dst[scan[i * 8 + j + 4]] = (*ext)[j];
284 for (i = 0; i < 64; i++)
285 dst[scan[i]] = (*ext)[i];
290 static void unquant_block(int16_t *block, int q)
294 for (i = 0; i < 64; i++) {
295 int val = (uint16_t)block[i];
298 block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
303 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
304 const uint8_t *src, int src_size)
308 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
311 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
312 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
313 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
314 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
315 const int ystride = ctx->frame->linesize[0];
317 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
318 for (i = 0; i < 2; i++)
319 C[i] = ctx->frame->data[i + 1] + mb_x * 8
320 + mb_y * 8 * ctx->frame->linesize[i + 1];
321 init_get_bits(&gb, src, src_size * 8);
323 memset(ctx->slice_data, 0,
324 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
325 for (i = 0; i < NUM_BANDS; i++)
326 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
328 !ctx->interlaced)) < 0)
331 for (mb = 0; mb < slice_width; mb++) {
332 for (blk = 0; blk < 4; blk++) {
333 if (!ctx->interlaced)
334 recombine_block(ctx->block, ctx->scantable.permutated,
337 recombine_block_il(ctx->block, ctx->scantable.permutated,
338 &base_y, &ext_y, blk);
339 unquant_block(ctx->block, ctx->quant);
340 ctx->dsp.idct(ctx->block);
342 if (!ctx->interlaced) {
343 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
344 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
347 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
348 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
354 for (blk = 0; blk < 2; blk++) {
355 recombine_block(ctx->block, ctx->scantable.permutated,
357 unquant_block(ctx->block, ctx->quant);
358 ctx->dsp.idct(ctx->block);
359 ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
360 ctx->frame->linesize[blk + 1]);
368 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
371 AICContext *ctx = avctx->priv_data;
372 const uint8_t *buf = avpkt->data;
373 int buf_size = avpkt->size;
380 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
381 ctx->frame->key_frame = 1;
383 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
385 if (buf_size < off) {
386 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
387 return AVERROR_INVALIDDATA;
390 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
393 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
396 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
397 ctx->num_x_slices * ctx->mb_height * 2);
399 for (y = 0; y < ctx->mb_height; y++) {
400 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
401 slice_size = bytestream2_get_le16(&gb) * 4;
402 if (slice_size + off > buf_size || !slice_size) {
403 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
404 return AVERROR_INVALIDDATA;
407 if ((ret = aic_decode_slice(ctx, x, y,
408 buf + off, slice_size)) < 0)
420 static av_cold int aic_decode_init(AVCodecContext *avctx)
422 AICContext *ctx = avctx->priv_data;
428 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
430 ff_dsputil_init(&ctx->dsp, avctx);
432 for (i = 0; i < 64; i++)
434 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
436 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
437 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
439 ctx->num_x_slices = 16;
440 ctx->slice_width = ctx->mb_width / 16;
441 for (i = 1; i < 32; i++) {
442 if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
443 ctx->slice_width = ctx->mb_width / i;
444 ctx->num_x_slices = i;
449 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
450 * sizeof(*ctx->slice_data));
451 if (!ctx->slice_data) {
452 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
454 return AVERROR(ENOMEM);
457 for (i = 0; i < NUM_BANDS; i++)
458 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
464 static av_cold int aic_decode_close(AVCodecContext *avctx)
466 AICContext *ctx = avctx->priv_data;
468 av_freep(&ctx->slice_data);
473 AVCodec ff_aic_decoder = {
475 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
476 .type = AVMEDIA_TYPE_VIDEO,
477 .id = AV_CODEC_ID_AIC,
478 .priv_data_size = sizeof(AICContext),
479 .init = aic_decode_init,
480 .close = aic_decode_close,
481 .decode = aic_decode_frame,
482 .capabilities = CODEC_CAP_DR1,