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 "thread.h"
32 #include "unary.h"
33
34 #define AIC_HDR_SIZE 24
35 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
36
37 enum AICBands {
38 COEFF_LUMA = 0,
39 COEFF_CHROMA,
40 COEFF_LUMA_EXT,
41 COEFF_CHROMA_EXT,
42 NUM_BANDS
43 };
44
45 static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46
47 static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
48
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,
58 };
59
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,
69 };
70
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,
96 };
97
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,
107 };
108
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,
134 };
135
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
138 };
139
140 typedef struct AICContext {
141 AVCodecContext *avctx;
142 AVFrame *frame;
143 IDCTDSPContext idsp;
144 ScanTable scantable;
145
146 int num_x_slices;
147 int slice_width;
148 int mb_width, mb_height;
149 int quant;
150 int interlaced;
151
152 int16_t *slice_data;
153 int16_t *data_ptr[NUM_BANDS];
154
155 DECLARE_ALIGNED(16, int16_t, block)[64];
156 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
157 } AICContext;
158
aic_decode_header(AICContext * ctx,const uint8_t * src,int size)159 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
160 {
161 uint32_t frame_size;
162 int width, height;
163
164 if (src[0] != 1) {
165 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
166 return AVERROR_INVALIDDATA;
167 }
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;
171 }
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",
177 frame_size, size);
178 return AVERROR_INVALIDDATA;
179 }
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;
185 }
186 ctx->quant = src[15];
187 ctx->interlaced = ((src[16] >> 4) == 3);
188
189 return 0;
190 }
191
192 #define GET_CODE(val, type, add_bits) \
193 do { \
194 if (type) \
195 val = get_ue_golomb(gb); \
196 else \
197 val = get_unary(gb, 1, 31); \
198 if (add_bits) \
199 val = (val << add_bits) + get_bits(gb, add_bits); \
200 } while (0)
201
aic_decode_coeffs(GetBitContext * gb,int16_t * dst,int band,int slice_width,int force_chroma)202 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
203 int band, int slice_width, int force_chroma)
204 {
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];
208 int mb, idx;
209 unsigned val;
210
211 if (get_bits_left(gb) < 5)
212 return AVERROR_INVALIDDATA;
213
214 has_skips = get_bits1(gb);
215 coeff_type = get_bits1(gb);
216 coeff_bits = get_bits(gb, 3);
217
218 if (has_skips) {
219 skip_type = get_bits1(gb);
220 skip_bits = get_bits(gb, 3);
221
222 for (mb = 0; mb < slice_width; mb++) {
223 idx = -1;
224 do {
225 GET_CODE(val, skip_type, skip_bits);
226 if (val >= 0x10000)
227 return AVERROR_INVALIDDATA;
228 idx += val + 1;
229 if (idx >= num_coeffs)
230 break;
231 GET_CODE(val, coeff_type, coeff_bits);
232 val++;
233 if (val >= 0x10000)
234 return AVERROR_INVALIDDATA;
235 dst[scan[idx]] = val;
236 } while (idx < num_coeffs - 1);
237 dst += num_coeffs;
238 }
239 } else {
240 for (mb = 0; mb < slice_width; mb++) {
241 for (idx = 0; idx < num_coeffs; idx++) {
242 GET_CODE(val, coeff_type, coeff_bits);
243 if (val >= 0x10000)
244 return AVERROR_INVALIDDATA;
245 dst[scan[idx]] = val;
246 }
247 dst += num_coeffs;
248 }
249 }
250 return 0;
251 }
252
recombine_block(int16_t * dst,const uint8_t * scan,int16_t ** base,int16_t ** ext)253 static void recombine_block(int16_t *dst, const uint8_t *scan,
254 int16_t **base, int16_t **ext)
255 {
256 int i, j;
257
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];
263 *base += 4;
264 *ext += 4;
265 }
266 for (; i < 8; i++) {
267 for (j = 0; j < 8; j++)
268 dst[scan[i * 8 + j]] = (*ext)[j];
269 *ext += 8;
270 }
271 }
272
recombine_block_il(int16_t * dst,const uint8_t * scan,int16_t ** base,int16_t ** ext,int block_no)273 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
274 int16_t **base, int16_t **ext,
275 int block_no)
276 {
277 int i, j;
278
279 if (block_no < 2) {
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];
285 *base += 4;
286 *ext += 4;
287 }
288 } else {
289 for (i = 0; i < 64; i++)
290 dst[scan[i]] = (*ext)[i];
291 *ext += 64;
292 }
293 }
294
unquant_block(int16_t * block,int q,uint8_t * quant_matrix)295 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
296 {
297 int i;
298
299 for (i = 0; i < 64; i++) {
300 int val = (uint16_t)block[i];
301 int sign = val & 1;
302
303 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
304 + sign;
305 }
306 }
307
aic_decode_slice(AICContext * ctx,int mb_x,int mb_y,const uint8_t * src,int src_size)308 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
309 const uint8_t *src, int src_size)
310 {
311 GetBitContext gb;
312 int ret, i, mb, blk;
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;
315 int y_pos, c_pos;
316 uint8_t *Y, *C[2];
317 uint8_t *dst;
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];
323
324 if (last_row) {
325 y_pos = (ctx->avctx->height - 16);
326 c_pos = ((ctx->avctx->height+1)/2 - 8);
327 } else {
328 y_pos = mb_y * 16;
329 c_pos = mb_y * 8;
330 }
331
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);
337
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],
342 i, slice_width,
343 !ctx->interlaced)) < 0)
344 return ret;
345
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,
350 &base_y, &ext_y);
351 else
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);
356
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);
360 } else {
361 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
362 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
363 ystride * 2);
364 }
365 }
366 Y += 16;
367
368 for (blk = 0; blk < 2; blk++) {
369 recombine_block(ctx->block, ctx->scantable.permutated,
370 &base_c, &ext_c);
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]);
375 C[blk] += 8;
376 }
377 }
378
379 return 0;
380 }
381
aic_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)382 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
383 AVPacket *avpkt)
384 {
385 AICContext *ctx = avctx->priv_data;
386 const uint8_t *buf = avpkt->data;
387 int buf_size = avpkt->size;
388 GetByteContext gb;
389 uint32_t off;
390 int x, y, ret;
391 int slice_size;
392 ThreadFrame frame = { .f = data };
393
394 ctx->frame = data;
395 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
396 ctx->frame->key_frame = 1;
397
398 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
399
400 if (buf_size < off) {
401 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
402 return AVERROR_INVALIDDATA;
403 }
404
405 ret = aic_decode_header(ctx, buf, buf_size);
406 if (ret < 0) {
407 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
408 return ret;
409 }
410
411 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
412 return ret;
413
414 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
415 ctx->num_x_slices * ctx->mb_height * 2);
416
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;
424 }
425
426 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
427 if (ret < 0) {
428 av_log(avctx, AV_LOG_ERROR,
429 "Error decoding slice at %d.%d\n", x, y);
430 return ret;
431 }
432
433 off += slice_size;
434 }
435 }
436
437 *got_frame = 1;
438
439 return avpkt->size;
440 }
441
aic_decode_init(AVCodecContext * avctx)442 static av_cold int aic_decode_init(AVCodecContext *avctx)
443 {
444 AICContext *ctx = avctx->priv_data;
445 int i;
446 uint8_t scan[64];
447
448 ctx->avctx = avctx;
449
450 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
451
452 ff_idctdsp_init(&ctx->idsp, avctx);
453
454 for (i = 0; i < 64; i++)
455 scan[i] = 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];
459
460 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
461 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
462
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;
469 break;
470 }
471 }
472
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");
477
478 return AVERROR(ENOMEM);
479 }
480
481 for (i = 0; i < NUM_BANDS; i++)
482 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
483 * aic_band_off[i];
484
485 return 0;
486 }
487
aic_decode_close(AVCodecContext * avctx)488 static av_cold int aic_decode_close(AVCodecContext *avctx)
489 {
490 AICContext *ctx = avctx->priv_data;
491
492 av_freep(&ctx->slice_data);
493
494 return 0;
495 }
496
497 AVCodec ff_aic_decoder = {
498 .name = "aic",
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,
508 };
509