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