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 "codec_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,AVFrame * frame,int * got_frame,AVPacket * avpkt)384 static int aic_decode_frame(AVCodecContext *avctx, AVFrame *frame,
385 int *got_frame, 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
395 ctx->frame = frame;
396 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
397 ctx->frame->key_frame = 1;
398
399 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
400
401 if (buf_size < off) {
402 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
403 return AVERROR_INVALIDDATA;
404 }
405
406 ret = aic_decode_header(ctx, buf, buf_size);
407 if (ret < 0) {
408 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
409 return ret;
410 }
411
412 if ((ret = ff_thread_get_buffer(avctx, ctx->frame, 0)) < 0)
413 return ret;
414
415 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
416 ctx->num_x_slices * ctx->mb_height * 2);
417
418 for (y = 0; y < ctx->mb_height; y++) {
419 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
420 slice_size = bytestream2_get_le16(&gb) * 4;
421 if (slice_size + off > buf_size || !slice_size) {
422 av_log(avctx, AV_LOG_ERROR,
423 "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
424 return AVERROR_INVALIDDATA;
425 }
426
427 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
428 if (ret < 0) {
429 av_log(avctx, AV_LOG_ERROR,
430 "Error decoding slice at %d.%d\n", x, y);
431 return ret;
432 }
433
434 off += slice_size;
435 }
436 }
437
438 *got_frame = 1;
439
440 return avpkt->size;
441 }
442
aic_decode_init(AVCodecContext * avctx)443 static av_cold int aic_decode_init(AVCodecContext *avctx)
444 {
445 AICContext *ctx = avctx->priv_data;
446 int i;
447 uint8_t scan[64];
448
449 ctx->avctx = avctx;
450
451 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
452
453 ff_idctdsp_init(&ctx->idsp, avctx);
454
455 for (i = 0; i < 64; i++)
456 scan[i] = i;
457 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
458 for (i = 0; i < 64; i++)
459 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
460
461 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
462 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
463
464 ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
465 ctx->slice_width = 16;
466 for (i = 1; i < ctx->mb_width; i++) {
467 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
468 ctx->slice_width = ctx->mb_width / i;
469 ctx->num_x_slices = i;
470 break;
471 }
472 }
473
474 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
475 * sizeof(*ctx->slice_data));
476 if (!ctx->slice_data) {
477 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
478
479 return AVERROR(ENOMEM);
480 }
481
482 for (i = 0; i < NUM_BANDS; i++)
483 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
484 * aic_band_off[i];
485
486 return 0;
487 }
488
aic_decode_close(AVCodecContext * avctx)489 static av_cold int aic_decode_close(AVCodecContext *avctx)
490 {
491 AICContext *ctx = avctx->priv_data;
492
493 av_freep(&ctx->slice_data);
494
495 return 0;
496 }
497
498 const FFCodec ff_aic_decoder = {
499 .p.name = "aic",
500 .p.long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
501 .p.type = AVMEDIA_TYPE_VIDEO,
502 .p.id = AV_CODEC_ID_AIC,
503 .priv_data_size = sizeof(AICContext),
504 .init = aic_decode_init,
505 .close = aic_decode_close,
506 FF_CODEC_DECODE_CB(aic_decode_frame),
507 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
508 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
509 };
510