1 /*
2 * Apple Intermediate Codec decoder
3 *
4 * Copyright (c) 2013 Konstantin Shishkov
5 *
6 * This file is part of FFmpeg.
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #include <inttypes.h>
24
25 #include "avcodec.h"
26 #include "bytestream.h"
27 #include "internal.h"
28 #include "get_bits.h"
29 #include "golomb.h"
30 #include "idctdsp.h"
31 #include "unary.h"
32
33 #define AIC_HDR_SIZE 24
34 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
35
36 enum AICBands {
37 COEFF_LUMA = 0,
38 COEFF_CHROMA,
39 COEFF_LUMA_EXT,
40 COEFF_CHROMA_EXT,
41 NUM_BANDS
42 };
43
44 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
45
46 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
47
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,
57 };
58
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,
68 };
69
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,
95 };
96
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,
106 };
107
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,
133 };
134
135 static const uint8_t * const aic_scan[NUM_BANDS] = {
136 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
137 };
138
139 typedef struct AICContext {
140 AVCodecContext *avctx;
141 AVFrame *frame;
142 IDCTDSPContext idsp;
143 ScanTable scantable;
144
145 int num_x_slices;
146 int slice_width;
147 int mb_width, mb_height;
148 int quant;
149 int interlaced;
150
151 int16_t *slice_data;
152 int16_t *data_ptr[NUM_BANDS];
153
154 DECLARE_ALIGNED(16, int16_t, block)[64];
155 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
156 } AICContext;
157
aic_decode_header(AICContext * ctx,const uint8_t * src,int size)158 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
159 {
160 uint32_t frame_size;
161 int width, height;
162
163 if (src[0] != 1) {
164 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
165 return AVERROR_INVALIDDATA;
166 }
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;
170 }
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",
176 frame_size, size);
177 return AVERROR_INVALIDDATA;
178 }
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;
184 }
185 ctx->quant = src[15];
186 ctx->interlaced = ((src[16] >> 4) == 3);
187
188 return 0;
189 }
190
191 #define GET_CODE(val, type, add_bits) \
192 do { \
193 if (type) \
194 val = get_ue_golomb(gb); \
195 else \
196 val = get_unary(gb, 1, 31); \
197 if (add_bits) \
198 val = (val << add_bits) + get_bits(gb, add_bits); \
199 } while (0)
200
aic_decode_coeffs(GetBitContext * gb,int16_t * dst,int band,int slice_width,int force_chroma)201 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
202 int band, int slice_width, int force_chroma)
203 {
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];
207 int mb, idx;
208 unsigned val;
209
210 has_skips = get_bits1(gb);
211 coeff_type = get_bits1(gb);
212 coeff_bits = get_bits(gb, 3);
213
214 if (has_skips) {
215 skip_type = get_bits1(gb);
216 skip_bits = get_bits(gb, 3);
217
218 for (mb = 0; mb < slice_width; mb++) {
219 idx = -1;
220 do {
221 GET_CODE(val, skip_type, skip_bits);
222 if (val >= 0x10000)
223 return AVERROR_INVALIDDATA;
224 idx += val + 1;
225 if (idx >= num_coeffs)
226 break;
227 GET_CODE(val, coeff_type, coeff_bits);
228 val++;
229 if (val >= 0x10000)
230 return AVERROR_INVALIDDATA;
231 dst[scan[idx]] = val;
232 } while (idx < num_coeffs - 1);
233 dst += num_coeffs;
234 }
235 } else {
236 for (mb = 0; mb < slice_width; mb++) {
237 for (idx = 0; idx < num_coeffs; idx++) {
238 GET_CODE(val, coeff_type, coeff_bits);
239 if (val >= 0x10000)
240 return AVERROR_INVALIDDATA;
241 dst[scan[idx]] = val;
242 }
243 dst += num_coeffs;
244 }
245 }
246 return 0;
247 }
248
recombine_block(int16_t * dst,const uint8_t * scan,int16_t ** base,int16_t ** ext)249 static void recombine_block(int16_t *dst, const uint8_t *scan,
250 int16_t **base, int16_t **ext)
251 {
252 int i, j;
253
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];
259 *base += 4;
260 *ext += 4;
261 }
262 for (; i < 8; i++) {
263 for (j = 0; j < 8; j++)
264 dst[scan[i * 8 + j]] = (*ext)[j];
265 *ext += 8;
266 }
267 }
268
recombine_block_il(int16_t * dst,const uint8_t * scan,int16_t ** base,int16_t ** ext,int block_no)269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
270 int16_t **base, int16_t **ext,
271 int block_no)
272 {
273 int i, j;
274
275 if (block_no < 2) {
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];
281 *base += 4;
282 *ext += 4;
283 }
284 } else {
285 for (i = 0; i < 64; i++)
286 dst[scan[i]] = (*ext)[i];
287 *ext += 64;
288 }
289 }
290
unquant_block(int16_t * block,int q,uint8_t * quant_matrix)291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
292 {
293 int i;
294
295 for (i = 0; i < 64; i++) {
296 int val = (uint16_t)block[i];
297 int sign = val & 1;
298
299 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
300 + sign;
301 }
302 }
303
aic_decode_slice(AICContext * ctx,int mb_x,int mb_y,const uint8_t * src,int src_size)304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
305 const uint8_t *src, int src_size)
306 {
307 GetBitContext gb;
308 int ret, i, mb, blk;
309 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
310 uint8_t *Y, *C[2];
311 uint8_t *dst;
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];
317
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);
323
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],
328 i, slice_width,
329 !ctx->interlaced)) < 0)
330 return ret;
331
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,
336 &base_y, &ext_y);
337 else
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->idsp.idct(ctx->block);
342
343 if (!ctx->interlaced) {
344 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
345 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
346 } else {
347 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
348 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
349 ystride * 2);
350 }
351 }
352 Y += 16;
353
354 for (blk = 0; blk < 2; blk++) {
355 recombine_block(ctx->block, ctx->scantable.permutated,
356 &base_c, &ext_c);
357 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
358 ctx->idsp.idct(ctx->block);
359 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
360 ctx->frame->linesize[blk + 1]);
361 C[blk] += 8;
362 }
363 }
364
365 return 0;
366 }
367
aic_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)368 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
369 AVPacket *avpkt)
370 {
371 AICContext *ctx = avctx->priv_data;
372 const uint8_t *buf = avpkt->data;
373 int buf_size = avpkt->size;
374 GetByteContext gb;
375 uint32_t off;
376 int x, y, ret;
377 int slice_size;
378
379 ctx->frame = data;
380 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
381 ctx->frame->key_frame = 1;
382
383 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
384
385 if (buf_size < off) {
386 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
387 return AVERROR_INVALIDDATA;
388 }
389
390 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
391 return ret;
392
393 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
394 return ret;
395
396 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
397 ctx->num_x_slices * ctx->mb_height * 2);
398
399 for (y = 0; y < ctx->mb_height; y++) {
400 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
401 slice_size = bytestream2_get_le16(&gb) * 4;
402 if (slice_size + off > buf_size || !slice_size) {
403 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
404 return AVERROR_INVALIDDATA;
405 }
406
407 if ((ret = aic_decode_slice(ctx, x, y,
408 buf + off, slice_size)) < 0)
409 return ret;
410
411 off += slice_size;
412 }
413 }
414
415 *got_frame = 1;
416
417 return avpkt->size;
418 }
419
aic_decode_init(AVCodecContext * avctx)420 static av_cold int aic_decode_init(AVCodecContext *avctx)
421 {
422 AICContext *ctx = avctx->priv_data;
423 int i;
424 uint8_t scan[64];
425
426 ctx->avctx = avctx;
427
428 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
429
430 ff_idctdsp_init(&ctx->idsp, avctx);
431
432 for (i = 0; i < 64; i++)
433 scan[i] = i;
434 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
435 for (i = 0; i < 64; i++)
436 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
437
438 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
439 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
440
441 ctx->num_x_slices = 16;
442 ctx->slice_width = ctx->mb_width / 16;
443 for (i = 1; i < 32; i++) {
444 if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
445 ctx->slice_width = ctx->mb_width / i;
446 ctx->num_x_slices = i;
447 break;
448 }
449 }
450
451 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
452 * sizeof(*ctx->slice_data));
453 if (!ctx->slice_data) {
454 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
455
456 return AVERROR(ENOMEM);
457 }
458
459 for (i = 0; i < NUM_BANDS; i++)
460 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
461 * aic_band_off[i];
462
463 return 0;
464 }
465
aic_decode_close(AVCodecContext * avctx)466 static av_cold int aic_decode_close(AVCodecContext *avctx)
467 {
468 AICContext *ctx = avctx->priv_data;
469
470 av_freep(&ctx->slice_data);
471
472 return 0;
473 }
474
475 AVCodec ff_aic_decoder = {
476 .name = "aic",
477 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
478 .type = AVMEDIA_TYPE_VIDEO,
479 .id = AV_CODEC_ID_AIC,
480 .priv_data_size = sizeof(AICContext),
481 .init = aic_decode_init,
482 .close = aic_decode_close,
483 .decode = aic_decode_frame,
484 .capabilities = CODEC_CAP_DR1,
485 };
486