avcodec/aic: Check remaining bits in aic_decode_coeffs()
[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 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 int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46
47 static const int 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
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
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
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
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
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
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
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
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
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     .init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
508     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
509 };