libfdk-aacdec: Decode the first AAC frame to reliably identify the bitstream
[ffmpeg.git] / libavcodec / aic.c
1 /*
2  * Apple Intermediate Codec decoder
3  *
4  * Copyright (c) 2013 Konstantin Shishkov
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 *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 } AICContext;
156
157 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
158 {
159     uint32_t frame_size;
160     int width, height;
161
162     if (src[0] != 1) {
163         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
164         return AVERROR_INVALIDDATA;
165     }
166     if (src[1] != AIC_HDR_SIZE - 2) {
167         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
168         return AVERROR_INVALIDDATA;
169     }
170     frame_size = AV_RB32(src + 2);
171     width      = AV_RB16(src + 6);
172     height     = AV_RB16(src + 8);
173     if (frame_size > size) {
174         av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
175                frame_size, size);
176         return AVERROR_INVALIDDATA;
177     }
178     if (width != ctx->avctx->width || height != ctx->avctx->height) {
179         av_log(ctx->avctx, AV_LOG_ERROR,
180                "Picture dimension changed: old: %d x %d, new: %d x %d\n",
181                ctx->avctx->width, ctx->avctx->height, width, height);
182         return AVERROR_INVALIDDATA;
183     }
184     ctx->quant      = src[15];
185     ctx->interlaced = ((src[16] >> 4) == 3);
186
187     return 0;
188 }
189
190 #define GET_CODE(val, type, add_bits)                         \
191     do {                                                      \
192         if (type)                                             \
193             val = get_ue_golomb(gb);                          \
194         else                                                  \
195             val = get_unary(gb, 1, 31);                       \
196         if (add_bits)                                         \
197             val = (val << add_bits) + get_bits(gb, add_bits); \
198     } while (0)
199
200 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
201                              int band, int slice_width, int force_chroma)
202 {
203     int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
204     const int num_coeffs = aic_num_band_coeffs[band];
205     const uint8_t *scan = aic_scan[band | force_chroma];
206     int mb, idx, val;
207
208     has_skips  = get_bits1(gb);
209     coeff_type = get_bits1(gb);
210     coeff_bits = get_bits(gb, 3);
211
212     if (has_skips) {
213         skip_type = get_bits1(gb);
214         skip_bits = get_bits(gb, 3);
215
216         for (mb = 0; mb < slice_width; mb++) {
217             idx = -1;
218             do {
219                 GET_CODE(val, skip_type, skip_bits);
220                 if (val < 0)
221                     return AVERROR_INVALIDDATA;
222                 idx += val + 1;
223                 if (idx >= num_coeffs)
224                     break;
225                 GET_CODE(val, coeff_type, coeff_bits);
226                 val++;
227                 if (val >= 0x10000 || val < 0)
228                     return AVERROR_INVALIDDATA;
229                 dst[scan[idx]] = val;
230             } while (idx < num_coeffs - 1);
231             dst += num_coeffs;
232         }
233     } else {
234         for (mb = 0; mb < slice_width; mb++) {
235             for (idx = 0; idx < num_coeffs; idx++) {
236                 GET_CODE(val, coeff_type, coeff_bits);
237                 if (val >= 0x10000 || val < 0)
238                     return AVERROR_INVALIDDATA;
239                 dst[scan[idx]] = val;
240             }
241             dst += num_coeffs;
242         }
243     }
244     return 0;
245 }
246
247 static void recombine_block(int16_t *dst, const uint8_t *scan,
248                             int16_t **base, int16_t **ext)
249 {
250     int i, j;
251
252     for (i = 0; i < 4; i++) {
253         for (j = 0; j < 4; j++)
254             dst[scan[i * 8 + j]]     = (*base)[j];
255         for (j = 0; j < 4; j++)
256             dst[scan[i * 8 + j + 4]] = (*ext)[j];
257         *base += 4;
258         *ext  += 4;
259     }
260     for (; i < 8; i++) {
261         for (j = 0; j < 8; j++)
262             dst[scan[i * 8 + j]] = (*ext)[j];
263         *ext  += 8;
264     }
265 }
266
267 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
268                                int16_t **base, int16_t **ext,
269                                int block_no)
270 {
271     int i, j;
272
273     if (block_no < 2) {
274         for (i = 0; i < 8; i++) {
275             for (j = 0; j < 4; j++)
276                 dst[scan[i * 8 + j]]     = (*base)[j];
277             for (j = 0; j < 4; j++)
278                 dst[scan[i * 8 + j + 4]] = (*ext)[j];
279             *base += 4;
280             *ext  += 4;
281         }
282     } else {
283         for (i = 0; i < 64; i++)
284             dst[scan[i]] = (*ext)[i];
285         *ext += 64;
286     }
287 }
288
289 static void unquant_block(int16_t *block, int q)
290 {
291     int i;
292
293     for (i = 0; i < 64; i++) {
294         int val  = (uint16_t)block[i];
295         int sign = val & 1;
296
297         block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
298                    + sign;
299     }
300 }
301
302 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
303                             const uint8_t *src, int src_size)
304 {
305     GetBitContext gb;
306     int ret, i, mb, blk;
307     int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
308     uint8_t *Y, *C[2];
309     uint8_t *dst;
310     int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
311     int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
312     int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
313     int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
314     const int ystride = ctx->frame->linesize[0];
315
316     Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
317     for (i = 0; i < 2; i++)
318         C[i] = ctx->frame->data[i + 1] + mb_x * 8
319                + mb_y * 8 * ctx->frame->linesize[i + 1];
320     init_get_bits(&gb, src, src_size * 8);
321
322     memset(ctx->slice_data, 0,
323            sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
324     for (i = 0; i < NUM_BANDS; i++)
325         if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
326                                      i, slice_width,
327                                      !ctx->interlaced)) < 0)
328             return ret;
329
330     for (mb = 0; mb < slice_width; mb++) {
331         for (blk = 0; blk < 4; blk++) {
332             if (!ctx->interlaced)
333                 recombine_block(ctx->block, ctx->scantable.permutated,
334                                 &base_y, &ext_y);
335             else
336                 recombine_block_il(ctx->block, ctx->scantable.permutated,
337                                    &base_y, &ext_y, blk);
338             unquant_block(ctx->block, ctx->quant);
339             ctx->idsp.idct(ctx->block);
340
341             if (!ctx->interlaced) {
342                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
343                 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
344             } else {
345                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
346                 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
347                                                     ystride * 2);
348             }
349         }
350         Y += 16;
351
352         for (blk = 0; blk < 2; blk++) {
353             recombine_block(ctx->block, ctx->scantable.permutated,
354                             &base_c, &ext_c);
355             unquant_block(ctx->block, ctx->quant);
356             ctx->idsp.idct(ctx->block);
357             ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
358                                                 ctx->frame->linesize[blk + 1]);
359             C[blk] += 8;
360         }
361     }
362
363     return 0;
364 }
365
366 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
367                             AVPacket *avpkt)
368 {
369     AICContext *ctx    = avctx->priv_data;
370     const uint8_t *buf = avpkt->data;
371     int buf_size       = avpkt->size;
372     GetByteContext gb;
373     uint32_t off;
374     int x, y, ret;
375     int slice_size;
376
377     ctx->frame            = data;
378     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
379     ctx->frame->key_frame = 1;
380
381     off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
382
383     if (buf_size < off) {
384         av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
385         return AVERROR_INVALIDDATA;
386     }
387
388     if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
389         return ret;
390
391     if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
392         return ret;
393
394     bytestream2_init(&gb, buf + AIC_HDR_SIZE,
395                      ctx->num_x_slices * ctx->mb_height * 2);
396
397     for (y = 0; y < ctx->mb_height; y++) {
398         for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
399             slice_size = bytestream2_get_le16(&gb) * 4;
400             if (slice_size + off > buf_size || !slice_size) {
401                 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
402                 return AVERROR_INVALIDDATA;
403             }
404
405             if ((ret = aic_decode_slice(ctx, x, y,
406                                         buf + off, slice_size)) < 0)
407                 return ret;
408
409             off += slice_size;
410         }
411     }
412
413     *got_frame = 1;
414
415     return avpkt->size;
416 }
417
418 static av_cold int aic_decode_init(AVCodecContext *avctx)
419 {
420     AICContext *ctx = avctx->priv_data;
421     int i;
422     uint8_t scan[64];
423
424     ctx->avctx = avctx;
425
426     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
427
428     ff_idctdsp_init(&ctx->idsp, avctx);
429
430     for (i = 0; i < 64; i++)
431         scan[i] = i;
432     ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
433
434     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
435     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
436
437     ctx->num_x_slices = 16;
438     ctx->slice_width  = ctx->mb_width / 16;
439     for (i = 1; i < 32; i++) {
440         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
441             ctx->slice_width  = ctx->mb_width / i;
442             ctx->num_x_slices = i;
443             break;
444         }
445     }
446
447     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
448                                 * sizeof(*ctx->slice_data));
449     if (!ctx->slice_data) {
450         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
451
452         return AVERROR(ENOMEM);
453     }
454
455     for (i = 0; i < NUM_BANDS; i++)
456         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
457                                              * aic_band_off[i];
458
459     return 0;
460 }
461
462 static av_cold int aic_decode_close(AVCodecContext *avctx)
463 {
464     AICContext *ctx = avctx->priv_data;
465
466     av_freep(&ctx->slice_data);
467
468     return 0;
469 }
470
471 AVCodec ff_aic_decoder = {
472     .name           = "aic",
473     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
474     .type           = AVMEDIA_TYPE_VIDEO,
475     .id             = AV_CODEC_ID_AIC,
476     .priv_data_size = sizeof(AICContext),
477     .init           = aic_decode_init,
478     .close          = aic_decode_close,
479     .decode         = aic_decode_frame,
480     .capabilities   = CODEC_CAP_DR1,
481 };