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
25 #include "libavutil/mem_internal.h"
28 #include "bytestream.h"
36 #define AIC_HDR_SIZE 24
37 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
47 static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
49 static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
51 static const uint8_t aic_quant_matrix[64] = {
52 8, 16, 19, 22, 22, 26, 26, 27,
53 16, 16, 22, 22, 26, 27, 27, 29,
54 19, 22, 26, 26, 27, 29, 29, 35,
55 22, 24, 27, 27, 29, 32, 34, 38,
56 26, 27, 29, 29, 32, 35, 38, 46,
57 27, 29, 34, 34, 35, 40, 46, 56,
58 29, 34, 34, 37, 40, 48, 56, 69,
59 34, 37, 38, 40, 48, 58, 69, 83,
62 static const uint8_t aic_y_scan[64] = {
63 0, 4, 1, 2, 5, 8, 12, 9,
64 6, 3, 7, 10, 13, 14, 11, 15,
65 47, 43, 46, 45, 42, 39, 35, 38,
66 41, 44, 40, 37, 34, 33, 36, 32,
67 16, 20, 17, 18, 21, 24, 28, 25,
68 22, 19, 23, 26, 29, 30, 27, 31,
69 63, 59, 62, 61, 58, 55, 51, 54,
70 57, 60, 56, 53, 50, 49, 52, 48,
73 static const uint8_t aic_y_ext_scan[192] = {
74 64, 72, 65, 66, 73, 80, 88, 81,
75 74, 67, 75, 82, 89, 90, 83, 91,
76 0, 4, 1, 2, 5, 8, 12, 9,
77 6, 3, 7, 10, 13, 14, 11, 15,
78 16, 20, 17, 18, 21, 24, 28, 25,
79 22, 19, 23, 26, 29, 30, 27, 31,
80 155, 147, 154, 153, 146, 139, 131, 138,
81 145, 152, 144, 137, 130, 129, 136, 128,
82 47, 43, 46, 45, 42, 39, 35, 38,
83 41, 44, 40, 37, 34, 33, 36, 32,
84 63, 59, 62, 61, 58, 55, 51, 54,
85 57, 60, 56, 53, 50, 49, 52, 48,
86 96, 104, 97, 98, 105, 112, 120, 113,
87 106, 99, 107, 114, 121, 122, 115, 123,
88 68, 76, 69, 70, 77, 84, 92, 85,
89 78, 71, 79, 86, 93, 94, 87, 95,
90 100, 108, 101, 102, 109, 116, 124, 117,
91 110, 103, 111, 118, 125, 126, 119, 127,
92 187, 179, 186, 185, 178, 171, 163, 170,
93 177, 184, 176, 169, 162, 161, 168, 160,
94 159, 151, 158, 157, 150, 143, 135, 142,
95 149, 156, 148, 141, 134, 133, 140, 132,
96 191, 183, 190, 189, 182, 175, 167, 174,
97 181, 188, 180, 173, 166, 165, 172, 164,
100 static const uint8_t aic_c_scan[64] = {
101 0, 4, 1, 2, 5, 8, 12, 9,
102 6, 3, 7, 10, 13, 14, 11, 15,
103 31, 27, 30, 29, 26, 23, 19, 22,
104 25, 28, 24, 21, 18, 17, 20, 16,
105 32, 36, 33, 34, 37, 40, 44, 41,
106 38, 35, 39, 42, 45, 46, 43, 47,
107 63, 59, 62, 61, 58, 55, 51, 54,
108 57, 60, 56, 53, 50, 49, 52, 48,
111 static const uint8_t aic_c_ext_scan[192] = {
112 16, 24, 17, 18, 25, 32, 40, 33,
113 26, 19, 27, 34, 41, 42, 35, 43,
114 0, 4, 1, 2, 5, 8, 12, 9,
115 6, 3, 7, 10, 13, 14, 11, 15,
116 20, 28, 21, 22, 29, 36, 44, 37,
117 30, 23, 31, 38, 45, 46, 39, 47,
118 95, 87, 94, 93, 86, 79, 71, 78,
119 85, 92, 84, 77, 70, 69, 76, 68,
120 63, 59, 62, 61, 58, 55, 51, 54,
121 57, 60, 56, 53, 50, 49, 52, 48,
122 91, 83, 90, 89, 82, 75, 67, 74,
123 81, 88, 80, 73, 66, 65, 72, 64,
124 112, 120, 113, 114, 121, 128, 136, 129,
125 122, 115, 123, 130, 137, 138, 131, 139,
126 96, 100, 97, 98, 101, 104, 108, 105,
127 102, 99, 103, 106, 109, 110, 107, 111,
128 116, 124, 117, 118, 125, 132, 140, 133,
129 126, 119, 127, 134, 141, 142, 135, 143,
130 191, 183, 190, 189, 182, 175, 167, 174,
131 181, 188, 180, 173, 166, 165, 172, 164,
132 159, 155, 158, 157, 154, 151, 147, 150,
133 153, 156, 152, 149, 146, 145, 148, 144,
134 187, 179, 186, 185, 178, 171, 163, 170,
135 177, 184, 176, 169, 162, 161, 168, 160,
138 static const uint8_t * const aic_scan[NUM_BANDS] = {
139 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
142 typedef struct AICContext {
143 AVCodecContext *avctx;
150 int mb_width, mb_height;
155 int16_t *data_ptr[NUM_BANDS];
157 DECLARE_ALIGNED(16, int16_t, block)[64];
158 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
161 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
167 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
168 return AVERROR_INVALIDDATA;
170 if (src[1] != AIC_HDR_SIZE - 2) {
171 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
172 return AVERROR_INVALIDDATA;
174 frame_size = AV_RB32(src + 2);
175 width = AV_RB16(src + 6);
176 height = AV_RB16(src + 8);
177 if (frame_size > size) {
178 av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
180 return AVERROR_INVALIDDATA;
182 if (width != ctx->avctx->width || height != ctx->avctx->height) {
183 av_log(ctx->avctx, AV_LOG_ERROR,
184 "Picture dimension changed: old: %d x %d, new: %d x %d\n",
185 ctx->avctx->width, ctx->avctx->height, width, height);
186 return AVERROR_INVALIDDATA;
188 ctx->quant = src[15];
189 ctx->interlaced = ((src[16] >> 4) == 3);
194 #define GET_CODE(val, type, add_bits) \
197 val = get_ue_golomb(gb); \
199 val = get_unary(gb, 1, 31); \
201 val = (val << add_bits) + get_bits(gb, add_bits); \
204 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
205 int band, int slice_width, int force_chroma)
207 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
208 const int num_coeffs = aic_num_band_coeffs[band];
209 const uint8_t *scan = aic_scan[band | force_chroma];
213 if (get_bits_left(gb) < 5)
214 return AVERROR_INVALIDDATA;
216 has_skips = get_bits1(gb);
217 coeff_type = get_bits1(gb);
218 coeff_bits = get_bits(gb, 3);
221 skip_type = get_bits1(gb);
222 skip_bits = get_bits(gb, 3);
224 for (mb = 0; mb < slice_width; mb++) {
227 GET_CODE(val, skip_type, skip_bits);
229 return AVERROR_INVALIDDATA;
231 if (idx >= num_coeffs)
233 GET_CODE(val, coeff_type, coeff_bits);
236 return AVERROR_INVALIDDATA;
237 dst[scan[idx]] = val;
238 } while (idx < num_coeffs - 1);
242 for (mb = 0; mb < slice_width; mb++) {
243 for (idx = 0; idx < num_coeffs; idx++) {
244 GET_CODE(val, coeff_type, coeff_bits);
246 return AVERROR_INVALIDDATA;
247 dst[scan[idx]] = val;
255 static void recombine_block(int16_t *dst, const uint8_t *scan,
256 int16_t **base, int16_t **ext)
260 for (i = 0; i < 4; i++) {
261 for (j = 0; j < 4; j++)
262 dst[scan[i * 8 + j]] = (*base)[j];
263 for (j = 0; j < 4; j++)
264 dst[scan[i * 8 + j + 4]] = (*ext)[j];
269 for (j = 0; j < 8; j++)
270 dst[scan[i * 8 + j]] = (*ext)[j];
275 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
276 int16_t **base, int16_t **ext,
282 for (i = 0; i < 8; i++) {
283 for (j = 0; j < 4; j++)
284 dst[scan[i * 8 + j]] = (*base)[j];
285 for (j = 0; j < 4; j++)
286 dst[scan[i * 8 + j + 4]] = (*ext)[j];
291 for (i = 0; i < 64; i++)
292 dst[scan[i]] = (*ext)[i];
297 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
301 for (i = 0; i < 64; i++) {
302 int val = (uint16_t)block[i];
305 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
310 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
311 const uint8_t *src, int src_size)
315 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
316 int last_row = mb_y && mb_y == ctx->mb_height - 1;
320 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
321 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
322 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
323 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
324 const int ystride = ctx->frame->linesize[0];
327 y_pos = (ctx->avctx->height - 16);
328 c_pos = ((ctx->avctx->height+1)/2 - 8);
334 Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
335 for (i = 0; i < 2; i++)
336 C[i] = ctx->frame->data[i + 1] + mb_x * 8
337 + c_pos * ctx->frame->linesize[i + 1];
338 init_get_bits(&gb, src, src_size * 8);
340 memset(ctx->slice_data, 0,
341 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
342 for (i = 0; i < NUM_BANDS; i++)
343 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
345 !ctx->interlaced)) < 0)
348 for (mb = 0; mb < slice_width; mb++) {
349 for (blk = 0; blk < 4; blk++) {
350 if (!ctx->interlaced)
351 recombine_block(ctx->block, ctx->scantable.permutated,
354 recombine_block_il(ctx->block, ctx->scantable.permutated,
355 &base_y, &ext_y, blk);
356 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
357 ctx->idsp.idct(ctx->block);
359 if (!ctx->interlaced) {
360 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
361 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
363 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
364 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
370 for (blk = 0; blk < 2; blk++) {
371 recombine_block(ctx->block, ctx->scantable.permutated,
373 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
374 ctx->idsp.idct(ctx->block);
375 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
376 ctx->frame->linesize[blk + 1]);
384 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
387 AICContext *ctx = avctx->priv_data;
388 const uint8_t *buf = avpkt->data;
389 int buf_size = avpkt->size;
394 ThreadFrame frame = { .f = data };
397 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
398 ctx->frame->key_frame = 1;
400 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
402 if (buf_size < off) {
403 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
404 return AVERROR_INVALIDDATA;
407 ret = aic_decode_header(ctx, buf, buf_size);
409 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
413 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
416 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
417 ctx->num_x_slices * ctx->mb_height * 2);
419 for (y = 0; y < ctx->mb_height; y++) {
420 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
421 slice_size = bytestream2_get_le16(&gb) * 4;
422 if (slice_size + off > buf_size || !slice_size) {
423 av_log(avctx, AV_LOG_ERROR,
424 "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
425 return AVERROR_INVALIDDATA;
428 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
430 av_log(avctx, AV_LOG_ERROR,
431 "Error decoding slice at %d.%d\n", x, y);
444 static av_cold int aic_decode_init(AVCodecContext *avctx)
446 AICContext *ctx = avctx->priv_data;
452 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
454 ff_idctdsp_init(&ctx->idsp, avctx);
456 for (i = 0; i < 64; i++)
458 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
459 for (i = 0; i < 64; i++)
460 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
462 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
463 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
465 ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
466 ctx->slice_width = 16;
467 for (i = 1; i < ctx->mb_width; i++) {
468 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
469 ctx->slice_width = ctx->mb_width / i;
470 ctx->num_x_slices = i;
475 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
476 * sizeof(*ctx->slice_data));
477 if (!ctx->slice_data) {
478 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
480 return AVERROR(ENOMEM);
483 for (i = 0; i < NUM_BANDS; i++)
484 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
490 static av_cold int aic_decode_close(AVCodecContext *avctx)
492 AICContext *ctx = avctx->priv_data;
494 av_freep(&ctx->slice_data);
499 AVCodec ff_aic_decoder = {
501 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
502 .type = AVMEDIA_TYPE_VIDEO,
503 .id = AV_CODEC_ID_AIC,
504 .priv_data_size = sizeof(AICContext),
505 .init = aic_decode_init,
506 .close = aic_decode_close,
507 .decode = aic_decode_frame,
508 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
509 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,