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];
155 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
158 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
164 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
165 return AVERROR_INVALIDDATA;
167 if (src[1] != AIC_HDR_SIZE - 2) {
168 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
169 return AVERROR_INVALIDDATA;
171 frame_size = AV_RB32(src + 2);
172 width = AV_RB16(src + 6);
173 height = AV_RB16(src + 8);
174 if (frame_size > size) {
175 av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
177 return AVERROR_INVALIDDATA;
179 if (width != ctx->avctx->width || height != ctx->avctx->height) {
180 av_log(ctx->avctx, AV_LOG_ERROR,
181 "Picture dimension changed: old: %d x %d, new: %d x %d\n",
182 ctx->avctx->width, ctx->avctx->height, width, height);
183 return AVERROR_INVALIDDATA;
185 ctx->quant = src[15];
186 ctx->interlaced = ((src[16] >> 4) == 3);
191 #define GET_CODE(val, type, add_bits) \
194 val = get_ue_golomb(gb); \
196 val = get_unary(gb, 1, 31); \
198 val = (val << add_bits) + get_bits(gb, add_bits); \
201 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
202 int band, int slice_width, int force_chroma)
204 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
205 const int num_coeffs = aic_num_band_coeffs[band];
206 const uint8_t *scan = aic_scan[band | force_chroma];
210 has_skips = get_bits1(gb);
211 coeff_type = get_bits1(gb);
212 coeff_bits = get_bits(gb, 3);
215 skip_type = get_bits1(gb);
216 skip_bits = get_bits(gb, 3);
218 for (mb = 0; mb < slice_width; mb++) {
221 GET_CODE(val, skip_type, skip_bits);
223 return AVERROR_INVALIDDATA;
225 if (idx >= num_coeffs)
227 GET_CODE(val, coeff_type, coeff_bits);
230 return AVERROR_INVALIDDATA;
231 dst[scan[idx]] = val;
232 } while (idx < num_coeffs - 1);
236 for (mb = 0; mb < slice_width; mb++) {
237 for (idx = 0; idx < num_coeffs; idx++) {
238 GET_CODE(val, coeff_type, coeff_bits);
240 return AVERROR_INVALIDDATA;
241 dst[scan[idx]] = val;
249 static void recombine_block(int16_t *dst, const uint8_t *scan,
250 int16_t **base, int16_t **ext)
254 for (i = 0; i < 4; i++) {
255 for (j = 0; j < 4; j++)
256 dst[scan[i * 8 + j]] = (*base)[j];
257 for (j = 0; j < 4; j++)
258 dst[scan[i * 8 + j + 4]] = (*ext)[j];
263 for (j = 0; j < 8; j++)
264 dst[scan[i * 8 + j]] = (*ext)[j];
269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
270 int16_t **base, int16_t **ext,
276 for (i = 0; i < 8; i++) {
277 for (j = 0; j < 4; j++)
278 dst[scan[i * 8 + j]] = (*base)[j];
279 for (j = 0; j < 4; j++)
280 dst[scan[i * 8 + j + 4]] = (*ext)[j];
285 for (i = 0; i < 64; i++)
286 dst[scan[i]] = (*ext)[i];
291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
295 for (i = 0; i < 64; i++) {
296 int val = (uint16_t)block[i];
299 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
305 const uint8_t *src, int src_size)
309 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
312 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
313 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
314 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
315 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
316 const int ystride = ctx->frame->linesize[0];
318 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
319 for (i = 0; i < 2; i++)
320 C[i] = ctx->frame->data[i + 1] + mb_x * 8
321 + mb_y * 8 * ctx->frame->linesize[i + 1];
322 init_get_bits(&gb, src, src_size * 8);
324 memset(ctx->slice_data, 0,
325 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
326 for (i = 0; i < NUM_BANDS; i++)
327 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
329 !ctx->interlaced)) < 0)
332 for (mb = 0; mb < slice_width; mb++) {
333 for (blk = 0; blk < 4; blk++) {
334 if (!ctx->interlaced)
335 recombine_block(ctx->block, ctx->scantable.permutated,
338 recombine_block_il(ctx->block, ctx->scantable.permutated,
339 &base_y, &ext_y, blk);
340 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
341 ctx->dsp.idct(ctx->block);
343 if (!ctx->interlaced) {
344 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
345 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
348 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
349 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
355 for (blk = 0; blk < 2; blk++) {
356 recombine_block(ctx->block, ctx->scantable.permutated,
358 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
359 ctx->dsp.idct(ctx->block);
360 ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
361 ctx->frame->linesize[blk + 1]);
369 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
372 AICContext *ctx = avctx->priv_data;
373 const uint8_t *buf = avpkt->data;
374 int buf_size = avpkt->size;
381 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
382 ctx->frame->key_frame = 1;
384 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
386 if (buf_size < off) {
387 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
388 return AVERROR_INVALIDDATA;
391 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
394 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
397 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
398 ctx->num_x_slices * ctx->mb_height * 2);
400 for (y = 0; y < ctx->mb_height; y++) {
401 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
402 slice_size = bytestream2_get_le16(&gb) * 4;
403 if (slice_size + off > buf_size || !slice_size) {
404 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
405 return AVERROR_INVALIDDATA;
408 if ((ret = aic_decode_slice(ctx, x, y,
409 buf + off, slice_size)) < 0)
421 static av_cold int aic_decode_init(AVCodecContext *avctx)
423 AICContext *ctx = avctx->priv_data;
429 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
431 ff_dsputil_init(&ctx->dsp, avctx);
433 for (i = 0; i < 64; i++)
435 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
436 for (i = 0; i < 64; i++)
437 ctx->quant_matrix[ctx->dsp.idct_permutation[i]] = aic_quant_matrix[i];
439 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
440 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
442 ctx->num_x_slices = 16;
443 ctx->slice_width = ctx->mb_width / 16;
444 for (i = 1; i < 32; i++) {
445 if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
446 ctx->slice_width = ctx->mb_width / i;
447 ctx->num_x_slices = i;
452 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
453 * sizeof(*ctx->slice_data));
454 if (!ctx->slice_data) {
455 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
457 return AVERROR(ENOMEM);
460 for (i = 0; i < NUM_BANDS; i++)
461 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
467 static av_cold int aic_decode_close(AVCodecContext *avctx)
469 AICContext *ctx = avctx->priv_data;
471 av_freep(&ctx->slice_data);
476 AVCodec ff_aic_decoder = {
478 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
479 .type = AVMEDIA_TYPE_VIDEO,
480 .id = AV_CODEC_ID_AIC,
481 .priv_data_size = sizeof(AICContext),
482 .init = aic_decode_init,
483 .close = aic_decode_close,
484 .decode = aic_decode_frame,
485 .capabilities = CODEC_CAP_DR1,