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
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];
207 has_skips = get_bits1(gb);
208 coeff_type = get_bits1(gb);
209 coeff_bits = get_bits(gb, 3);
212 skip_type = get_bits1(gb);
213 skip_bits = get_bits(gb, 3);
215 for (mb = 0; mb < slice_width; mb++) {
218 GET_CODE(val, skip_type, skip_bits);
220 return AVERROR_INVALIDDATA;
222 if (idx >= num_coeffs)
224 GET_CODE(val, coeff_type, coeff_bits);
227 return AVERROR_INVALIDDATA;
228 dst[scan[idx]] = val;
229 } while (idx < num_coeffs - 1);
233 for (mb = 0; mb < slice_width; mb++) {
234 for (idx = 0; idx < num_coeffs; idx++) {
235 GET_CODE(val, coeff_type, coeff_bits);
237 return AVERROR_INVALIDDATA;
238 dst[scan[idx]] = val;
246 static void recombine_block(int16_t *dst, const uint8_t *scan,
247 int16_t **base, int16_t **ext)
251 for (i = 0; i < 4; i++) {
252 for (j = 0; j < 4; j++)
253 dst[scan[i * 8 + j]] = (*base)[j];
254 for (j = 0; j < 4; j++)
255 dst[scan[i * 8 + j + 4]] = (*ext)[j];
260 for (j = 0; j < 8; j++)
261 dst[scan[i * 8 + j]] = (*ext)[j];
266 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
267 int16_t **base, int16_t **ext,
273 for (i = 0; i < 8; i++) {
274 for (j = 0; j < 4; j++)
275 dst[scan[i * 8 + j]] = (*base)[j];
276 for (j = 0; j < 4; j++)
277 dst[scan[i * 8 + j + 4]] = (*ext)[j];
282 for (i = 0; i < 64; i++)
283 dst[scan[i]] = (*ext)[i];
288 static void unquant_block(int16_t *block, int q)
292 for (i = 0; i < 64; i++) {
293 int val = (uint16_t)block[i];
296 block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
301 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
302 const uint8_t *src, int src_size)
306 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
309 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
310 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
311 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
312 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
313 const int ystride = ctx->frame->linesize[0];
315 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
316 for (i = 0; i < 2; i++)
317 C[i] = ctx->frame->data[i + 1] + mb_x * 8
318 + mb_y * 8 * ctx->frame->linesize[i + 1];
319 init_get_bits(&gb, src, src_size * 8);
321 memset(ctx->slice_data, 0,
322 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
323 for (i = 0; i < NUM_BANDS; i++)
324 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
326 !ctx->interlaced)) < 0)
329 for (mb = 0; mb < slice_width; mb++) {
330 for (blk = 0; blk < 4; blk++) {
331 if (!ctx->interlaced)
332 recombine_block(ctx->block, ctx->scantable.permutated,
335 recombine_block_il(ctx->block, ctx->scantable.permutated,
336 &base_y, &ext_y, blk);
337 unquant_block(ctx->block, ctx->quant);
338 ctx->dsp.idct(ctx->block);
340 if (!ctx->interlaced) {
341 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
342 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
345 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
346 ctx->dsp.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->dsp.idct(ctx->block);
357 ctx->dsp.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_dsputil_init(&ctx->dsp, avctx);
430 for (i = 0; i < 64; i++)
432 ff_init_scantable(ctx->dsp.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 .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,
480 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec")