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 int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
47 static const int 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 has_skips = get_bits1(gb);
212 coeff_type = get_bits1(gb);
213 coeff_bits = get_bits(gb, 3);
216 skip_type = get_bits1(gb);
217 skip_bits = get_bits(gb, 3);
219 for (mb = 0; mb < slice_width; mb++) {
222 GET_CODE(val, skip_type, skip_bits);
224 return AVERROR_INVALIDDATA;
226 if (idx >= num_coeffs)
228 GET_CODE(val, coeff_type, coeff_bits);
231 return AVERROR_INVALIDDATA;
232 dst[scan[idx]] = val;
233 } while (idx < num_coeffs - 1);
237 for (mb = 0; mb < slice_width; mb++) {
238 for (idx = 0; idx < num_coeffs; idx++) {
239 GET_CODE(val, coeff_type, coeff_bits);
241 return AVERROR_INVALIDDATA;
242 dst[scan[idx]] = val;
250 static void recombine_block(int16_t *dst, const uint8_t *scan,
251 int16_t **base, int16_t **ext)
255 for (i = 0; i < 4; i++) {
256 for (j = 0; j < 4; j++)
257 dst[scan[i * 8 + j]] = (*base)[j];
258 for (j = 0; j < 4; j++)
259 dst[scan[i * 8 + j + 4]] = (*ext)[j];
264 for (j = 0; j < 8; j++)
265 dst[scan[i * 8 + j]] = (*ext)[j];
270 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
271 int16_t **base, int16_t **ext,
277 for (i = 0; i < 8; i++) {
278 for (j = 0; j < 4; j++)
279 dst[scan[i * 8 + j]] = (*base)[j];
280 for (j = 0; j < 4; j++)
281 dst[scan[i * 8 + j + 4]] = (*ext)[j];
286 for (i = 0; i < 64; i++)
287 dst[scan[i]] = (*ext)[i];
292 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
296 for (i = 0; i < 64; i++) {
297 int val = (uint16_t)block[i];
300 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
305 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
306 const uint8_t *src, int src_size)
310 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
311 int last_row = mb_y && mb_y == ctx->mb_height - 1;
315 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
316 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
317 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
318 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
319 const int ystride = ctx->frame->linesize[0];
322 y_pos = (ctx->avctx->height - 16);
323 c_pos = ((ctx->avctx->height+1)/2 - 8);
329 Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
330 for (i = 0; i < 2; i++)
331 C[i] = ctx->frame->data[i + 1] + mb_x * 8
332 + c_pos * ctx->frame->linesize[i + 1];
333 init_get_bits(&gb, src, src_size * 8);
335 memset(ctx->slice_data, 0,
336 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
337 for (i = 0; i < NUM_BANDS; i++)
338 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
340 !ctx->interlaced)) < 0)
343 for (mb = 0; mb < slice_width; mb++) {
344 for (blk = 0; blk < 4; blk++) {
345 if (!ctx->interlaced)
346 recombine_block(ctx->block, ctx->scantable.permutated,
349 recombine_block_il(ctx->block, ctx->scantable.permutated,
350 &base_y, &ext_y, blk);
351 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
352 ctx->idsp.idct(ctx->block);
354 if (!ctx->interlaced) {
355 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
356 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
358 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
359 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
365 for (blk = 0; blk < 2; blk++) {
366 recombine_block(ctx->block, ctx->scantable.permutated,
368 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
369 ctx->idsp.idct(ctx->block);
370 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
371 ctx->frame->linesize[blk + 1]);
379 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
382 AICContext *ctx = avctx->priv_data;
383 const uint8_t *buf = avpkt->data;
384 int buf_size = avpkt->size;
389 ThreadFrame frame = { .f = data };
392 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
393 ctx->frame->key_frame = 1;
395 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
397 if (buf_size < off) {
398 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
399 return AVERROR_INVALIDDATA;
402 ret = aic_decode_header(ctx, buf, buf_size);
404 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
408 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
411 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
412 ctx->num_x_slices * ctx->mb_height * 2);
414 for (y = 0; y < ctx->mb_height; y++) {
415 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
416 slice_size = bytestream2_get_le16(&gb) * 4;
417 if (slice_size + off > buf_size || !slice_size) {
418 av_log(avctx, AV_LOG_ERROR,
419 "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
420 return AVERROR_INVALIDDATA;
423 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
425 av_log(avctx, AV_LOG_ERROR,
426 "Error decoding slice at %d.%d\n", x, y);
439 static av_cold int aic_decode_init(AVCodecContext *avctx)
441 AICContext *ctx = avctx->priv_data;
447 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
449 ff_idctdsp_init(&ctx->idsp, avctx);
451 for (i = 0; i < 64; i++)
453 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
454 for (i = 0; i < 64; i++)
455 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
457 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
458 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
460 ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
461 ctx->slice_width = 16;
462 for (i = 1; i < ctx->mb_width; i++) {
463 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
464 ctx->slice_width = ctx->mb_width / i;
465 ctx->num_x_slices = i;
470 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
471 * sizeof(*ctx->slice_data));
472 if (!ctx->slice_data) {
473 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
475 return AVERROR(ENOMEM);
478 for (i = 0; i < NUM_BANDS; i++)
479 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
485 static av_cold int aic_decode_close(AVCodecContext *avctx)
487 AICContext *ctx = avctx->priv_data;
489 av_freep(&ctx->slice_data);
494 AVCodec ff_aic_decoder = {
496 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
497 .type = AVMEDIA_TYPE_VIDEO,
498 .id = AV_CODEC_ID_AIC,
499 .priv_data_size = sizeof(AICContext),
500 .init = aic_decode_init,
501 .close = aic_decode_close,
502 .decode = aic_decode_frame,
503 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
504 .init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
505 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,