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