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"
34 #define AIC_HDR_SIZE 24
35 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
45 static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
47 static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
49 static const uint8_t aic_quant_matrix[64] = {
50 8, 16, 19, 22, 22, 26, 26, 27,
51 16, 16, 22, 22, 26, 27, 27, 29,
52 19, 22, 26, 26, 27, 29, 29, 35,
53 22, 24, 27, 27, 29, 32, 34, 38,
54 26, 27, 29, 29, 32, 35, 38, 46,
55 27, 29, 34, 34, 35, 40, 46, 56,
56 29, 34, 34, 37, 40, 48, 56, 69,
57 34, 37, 38, 40, 48, 58, 69, 83,
60 static const uint8_t aic_y_scan[64] = {
61 0, 4, 1, 2, 5, 8, 12, 9,
62 6, 3, 7, 10, 13, 14, 11, 15,
63 47, 43, 46, 45, 42, 39, 35, 38,
64 41, 44, 40, 37, 34, 33, 36, 32,
65 16, 20, 17, 18, 21, 24, 28, 25,
66 22, 19, 23, 26, 29, 30, 27, 31,
67 63, 59, 62, 61, 58, 55, 51, 54,
68 57, 60, 56, 53, 50, 49, 52, 48,
71 static const uint8_t aic_y_ext_scan[192] = {
72 64, 72, 65, 66, 73, 80, 88, 81,
73 74, 67, 75, 82, 89, 90, 83, 91,
74 0, 4, 1, 2, 5, 8, 12, 9,
75 6, 3, 7, 10, 13, 14, 11, 15,
76 16, 20, 17, 18, 21, 24, 28, 25,
77 22, 19, 23, 26, 29, 30, 27, 31,
78 155, 147, 154, 153, 146, 139, 131, 138,
79 145, 152, 144, 137, 130, 129, 136, 128,
80 47, 43, 46, 45, 42, 39, 35, 38,
81 41, 44, 40, 37, 34, 33, 36, 32,
82 63, 59, 62, 61, 58, 55, 51, 54,
83 57, 60, 56, 53, 50, 49, 52, 48,
84 96, 104, 97, 98, 105, 112, 120, 113,
85 106, 99, 107, 114, 121, 122, 115, 123,
86 68, 76, 69, 70, 77, 84, 92, 85,
87 78, 71, 79, 86, 93, 94, 87, 95,
88 100, 108, 101, 102, 109, 116, 124, 117,
89 110, 103, 111, 118, 125, 126, 119, 127,
90 187, 179, 186, 185, 178, 171, 163, 170,
91 177, 184, 176, 169, 162, 161, 168, 160,
92 159, 151, 158, 157, 150, 143, 135, 142,
93 149, 156, 148, 141, 134, 133, 140, 132,
94 191, 183, 190, 189, 182, 175, 167, 174,
95 181, 188, 180, 173, 166, 165, 172, 164,
98 static const uint8_t aic_c_scan[64] = {
99 0, 4, 1, 2, 5, 8, 12, 9,
100 6, 3, 7, 10, 13, 14, 11, 15,
101 31, 27, 30, 29, 26, 23, 19, 22,
102 25, 28, 24, 21, 18, 17, 20, 16,
103 32, 36, 33, 34, 37, 40, 44, 41,
104 38, 35, 39, 42, 45, 46, 43, 47,
105 63, 59, 62, 61, 58, 55, 51, 54,
106 57, 60, 56, 53, 50, 49, 52, 48,
109 static const uint8_t aic_c_ext_scan[192] = {
110 16, 24, 17, 18, 25, 32, 40, 33,
111 26, 19, 27, 34, 41, 42, 35, 43,
112 0, 4, 1, 2, 5, 8, 12, 9,
113 6, 3, 7, 10, 13, 14, 11, 15,
114 20, 28, 21, 22, 29, 36, 44, 37,
115 30, 23, 31, 38, 45, 46, 39, 47,
116 95, 87, 94, 93, 86, 79, 71, 78,
117 85, 92, 84, 77, 70, 69, 76, 68,
118 63, 59, 62, 61, 58, 55, 51, 54,
119 57, 60, 56, 53, 50, 49, 52, 48,
120 91, 83, 90, 89, 82, 75, 67, 74,
121 81, 88, 80, 73, 66, 65, 72, 64,
122 112, 120, 113, 114, 121, 128, 136, 129,
123 122, 115, 123, 130, 137, 138, 131, 139,
124 96, 100, 97, 98, 101, 104, 108, 105,
125 102, 99, 103, 106, 109, 110, 107, 111,
126 116, 124, 117, 118, 125, 132, 140, 133,
127 126, 119, 127, 134, 141, 142, 135, 143,
128 191, 183, 190, 189, 182, 175, 167, 174,
129 181, 188, 180, 173, 166, 165, 172, 164,
130 159, 155, 158, 157, 154, 151, 147, 150,
131 153, 156, 152, 149, 146, 145, 148, 144,
132 187, 179, 186, 185, 178, 171, 163, 170,
133 177, 184, 176, 169, 162, 161, 168, 160,
136 static const uint8_t * const aic_scan[NUM_BANDS] = {
137 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
140 typedef struct AICContext {
141 AVCodecContext *avctx;
148 int mb_width, mb_height;
153 int16_t *data_ptr[NUM_BANDS];
155 DECLARE_ALIGNED(16, int16_t, block)[64];
156 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
159 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
165 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
166 return AVERROR_INVALIDDATA;
168 if (src[1] != AIC_HDR_SIZE - 2) {
169 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
170 return AVERROR_INVALIDDATA;
172 frame_size = AV_RB32(src + 2);
173 width = AV_RB16(src + 6);
174 height = AV_RB16(src + 8);
175 if (frame_size > size) {
176 av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
178 return AVERROR_INVALIDDATA;
180 if (width != ctx->avctx->width || height != ctx->avctx->height) {
181 av_log(ctx->avctx, AV_LOG_ERROR,
182 "Picture dimension changed: old: %d x %d, new: %d x %d\n",
183 ctx->avctx->width, ctx->avctx->height, width, height);
184 return AVERROR_INVALIDDATA;
186 ctx->quant = src[15];
187 ctx->interlaced = ((src[16] >> 4) == 3);
192 #define GET_CODE(val, type, add_bits) \
195 val = get_ue_golomb(gb); \
197 val = get_unary(gb, 1, 31); \
199 val = (val << add_bits) + get_bits(gb, add_bits); \
202 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
203 int band, int slice_width, int force_chroma)
205 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
206 const int num_coeffs = aic_num_band_coeffs[band];
207 const uint8_t *scan = aic_scan[band | force_chroma];
211 if (get_bits_left(gb) < 5)
212 return AVERROR_INVALIDDATA;
214 has_skips = get_bits1(gb);
215 coeff_type = get_bits1(gb);
216 coeff_bits = get_bits(gb, 3);
219 skip_type = get_bits1(gb);
220 skip_bits = get_bits(gb, 3);
222 for (mb = 0; mb < slice_width; mb++) {
225 GET_CODE(val, skip_type, skip_bits);
227 return AVERROR_INVALIDDATA;
229 if (idx >= num_coeffs)
231 GET_CODE(val, coeff_type, coeff_bits);
234 return AVERROR_INVALIDDATA;
235 dst[scan[idx]] = val;
236 } while (idx < num_coeffs - 1);
240 for (mb = 0; mb < slice_width; mb++) {
241 for (idx = 0; idx < num_coeffs; idx++) {
242 GET_CODE(val, coeff_type, coeff_bits);
244 return AVERROR_INVALIDDATA;
245 dst[scan[idx]] = val;
253 static void recombine_block(int16_t *dst, const uint8_t *scan,
254 int16_t **base, int16_t **ext)
258 for (i = 0; i < 4; i++) {
259 for (j = 0; j < 4; j++)
260 dst[scan[i * 8 + j]] = (*base)[j];
261 for (j = 0; j < 4; j++)
262 dst[scan[i * 8 + j + 4]] = (*ext)[j];
267 for (j = 0; j < 8; j++)
268 dst[scan[i * 8 + j]] = (*ext)[j];
273 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
274 int16_t **base, int16_t **ext,
280 for (i = 0; i < 8; i++) {
281 for (j = 0; j < 4; j++)
282 dst[scan[i * 8 + j]] = (*base)[j];
283 for (j = 0; j < 4; j++)
284 dst[scan[i * 8 + j + 4]] = (*ext)[j];
289 for (i = 0; i < 64; i++)
290 dst[scan[i]] = (*ext)[i];
295 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
299 for (i = 0; i < 64; i++) {
300 int val = (uint16_t)block[i];
303 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
308 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
309 const uint8_t *src, int src_size)
313 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
314 int last_row = mb_y && mb_y == ctx->mb_height - 1;
318 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
319 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
320 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
321 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
322 const int ystride = ctx->frame->linesize[0];
325 y_pos = (ctx->avctx->height - 16);
326 c_pos = ((ctx->avctx->height+1)/2 - 8);
332 Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
333 for (i = 0; i < 2; i++)
334 C[i] = ctx->frame->data[i + 1] + mb_x * 8
335 + c_pos * ctx->frame->linesize[i + 1];
336 init_get_bits(&gb, src, src_size * 8);
338 memset(ctx->slice_data, 0,
339 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
340 for (i = 0; i < NUM_BANDS; i++)
341 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
343 !ctx->interlaced)) < 0)
346 for (mb = 0; mb < slice_width; mb++) {
347 for (blk = 0; blk < 4; blk++) {
348 if (!ctx->interlaced)
349 recombine_block(ctx->block, ctx->scantable.permutated,
352 recombine_block_il(ctx->block, ctx->scantable.permutated,
353 &base_y, &ext_y, blk);
354 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
355 ctx->idsp.idct(ctx->block);
357 if (!ctx->interlaced) {
358 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
359 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
361 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
362 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
368 for (blk = 0; blk < 2; blk++) {
369 recombine_block(ctx->block, ctx->scantable.permutated,
371 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
372 ctx->idsp.idct(ctx->block);
373 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
374 ctx->frame->linesize[blk + 1]);
382 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
385 AICContext *ctx = avctx->priv_data;
386 const uint8_t *buf = avpkt->data;
387 int buf_size = avpkt->size;
392 ThreadFrame frame = { .f = data };
395 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
396 ctx->frame->key_frame = 1;
398 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
400 if (buf_size < off) {
401 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
402 return AVERROR_INVALIDDATA;
405 ret = aic_decode_header(ctx, buf, buf_size);
407 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
411 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
414 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
415 ctx->num_x_slices * ctx->mb_height * 2);
417 for (y = 0; y < ctx->mb_height; y++) {
418 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
419 slice_size = bytestream2_get_le16(&gb) * 4;
420 if (slice_size + off > buf_size || !slice_size) {
421 av_log(avctx, AV_LOG_ERROR,
422 "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
423 return AVERROR_INVALIDDATA;
426 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
428 av_log(avctx, AV_LOG_ERROR,
429 "Error decoding slice at %d.%d\n", x, y);
442 static av_cold int aic_decode_init(AVCodecContext *avctx)
444 AICContext *ctx = avctx->priv_data;
450 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
452 ff_idctdsp_init(&ctx->idsp, avctx);
454 for (i = 0; i < 64; i++)
456 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
457 for (i = 0; i < 64; i++)
458 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
460 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
461 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
463 ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
464 ctx->slice_width = 16;
465 for (i = 1; i < ctx->mb_width; i++) {
466 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
467 ctx->slice_width = ctx->mb_width / i;
468 ctx->num_x_slices = i;
473 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
474 * sizeof(*ctx->slice_data));
475 if (!ctx->slice_data) {
476 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
478 return AVERROR(ENOMEM);
481 for (i = 0; i < NUM_BANDS; i++)
482 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
488 static av_cold int aic_decode_close(AVCodecContext *avctx)
490 AICContext *ctx = avctx->priv_data;
492 av_freep(&ctx->slice_data);
497 AVCodec ff_aic_decoder = {
499 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
500 .type = AVMEDIA_TYPE_VIDEO,
501 .id = AV_CODEC_ID_AIC,
502 .priv_data_size = sizeof(AICContext),
503 .init = aic_decode_init,
504 .close = aic_decode_close,
505 .decode = aic_decode_frame,
506 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
507 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,