Fix wmv1 encoding if all other msmpeg4-related encoders were disabled.
[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 "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     DECLARE_ALIGNED(16, uint8_t, quant_matrix)[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(gb);                          \
195         else                                                  \
196             val = get_unary(gb, 1, 31);                       \
197         if (add_bits)                                         \
198             val = (val << add_bits) + get_bits(gb, add_bits); \
199     } while (0)
200
201 static int aic_decode_coeffs(GetBitContext *gb, 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;
208     unsigned val;
209
210     has_skips  = get_bits1(gb);
211     coeff_type = get_bits1(gb);
212     coeff_bits = get_bits(gb, 3);
213
214     if (has_skips) {
215         skip_type = get_bits1(gb);
216         skip_bits = get_bits(gb, 3);
217
218         for (mb = 0; mb < slice_width; mb++) {
219             idx = -1;
220             do {
221                 GET_CODE(val, skip_type, skip_bits);
222                 if (val >= 0x10000)
223                     return AVERROR_INVALIDDATA;
224                 idx += val + 1;
225                 if (idx >= num_coeffs)
226                     break;
227                 GET_CODE(val, coeff_type, coeff_bits);
228                 val++;
229                 if (val >= 0x10000)
230                     return AVERROR_INVALIDDATA;
231                 dst[scan[idx]] = val;
232             } while (idx < num_coeffs - 1);
233             dst += num_coeffs;
234         }
235     } else {
236         for (mb = 0; mb < slice_width; mb++) {
237             for (idx = 0; idx < num_coeffs; idx++) {
238                 GET_CODE(val, coeff_type, coeff_bits);
239                 if (val >= 0x10000)
240                     return AVERROR_INVALIDDATA;
241                 dst[scan[idx]] = val;
242             }
243             dst += num_coeffs;
244         }
245     }
246     return 0;
247 }
248
249 static void recombine_block(int16_t *dst, const uint8_t *scan,
250                             int16_t **base, int16_t **ext)
251 {
252     int i, j;
253
254     for (i = 0; i < 4; i++) {
255         for (j = 0; j < 4; j++)
256             dst[scan[i * 8 + j]]     = (*base)[j];
257         for (j = 0; j < 4; j++)
258             dst[scan[i * 8 + j + 4]] = (*ext)[j];
259         *base += 4;
260         *ext  += 4;
261     }
262     for (; i < 8; i++) {
263         for (j = 0; j < 8; j++)
264             dst[scan[i * 8 + j]] = (*ext)[j];
265         *ext  += 8;
266     }
267 }
268
269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
270                                int16_t **base, int16_t **ext,
271                                int block_no)
272 {
273     int i, j;
274
275     if (block_no < 2) {
276         for (i = 0; i < 8; i++) {
277             for (j = 0; j < 4; j++)
278                 dst[scan[i * 8 + j]]     = (*base)[j];
279             for (j = 0; j < 4; j++)
280                 dst[scan[i * 8 + j + 4]] = (*ext)[j];
281             *base += 4;
282             *ext  += 4;
283         }
284     } else {
285         for (i = 0; i < 64; i++)
286             dst[scan[i]] = (*ext)[i];
287         *ext += 64;
288     }
289 }
290
291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
292 {
293     int i;
294
295     for (i = 0; i < 64; i++) {
296         int val  = (uint16_t)block[i];
297         int sign = val & 1;
298
299         block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
300                    + sign;
301     }
302 }
303
304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
305                             const uint8_t *src, int src_size)
306 {
307     GetBitContext gb;
308     int ret, i, mb, blk;
309     int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
310     uint8_t *Y, *C[2];
311     uint8_t *dst;
312     int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
313     int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
314     int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
315     int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
316     const int ystride = ctx->frame->linesize[0];
317
318     Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
319     for (i = 0; i < 2; i++)
320         C[i] = ctx->frame->data[i + 1] + mb_x * 8
321                + mb_y * 8 * ctx->frame->linesize[i + 1];
322     init_get_bits(&gb, src, src_size * 8);
323
324     memset(ctx->slice_data, 0,
325            sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
326     for (i = 0; i < NUM_BANDS; i++)
327         if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
328                                      i, slice_width,
329                                      !ctx->interlaced)) < 0)
330             return ret;
331
332     for (mb = 0; mb < slice_width; mb++) {
333         for (blk = 0; blk < 4; blk++) {
334             if (!ctx->interlaced)
335                 recombine_block(ctx->block, ctx->scantable.permutated,
336                                 &base_y, &ext_y);
337             else
338                 recombine_block_il(ctx->block, ctx->scantable.permutated,
339                                    &base_y, &ext_y, blk);
340             unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
341             ctx->idsp.idct(ctx->block);
342
343             if (!ctx->interlaced) {
344                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
345                 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
346             } else {
347                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
348                 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
349                                                     ystride * 2);
350             }
351         }
352         Y += 16;
353
354         for (blk = 0; blk < 2; blk++) {
355             recombine_block(ctx->block, ctx->scantable.permutated,
356                             &base_c, &ext_c);
357             unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
358             ctx->idsp.idct(ctx->block);
359             ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
360                                                 ctx->frame->linesize[blk + 1]);
361             C[blk] += 8;
362         }
363     }
364
365     return 0;
366 }
367
368 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
369                             AVPacket *avpkt)
370 {
371     AICContext *ctx    = avctx->priv_data;
372     const uint8_t *buf = avpkt->data;
373     int buf_size       = avpkt->size;
374     GetByteContext gb;
375     uint32_t off;
376     int x, y, ret;
377     int slice_size;
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     if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
391         return ret;
392
393     if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
394         return ret;
395
396     bytestream2_init(&gb, buf + AIC_HDR_SIZE,
397                      ctx->num_x_slices * ctx->mb_height * 2);
398
399     for (y = 0; y < ctx->mb_height; y++) {
400         for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
401             slice_size = bytestream2_get_le16(&gb) * 4;
402             if (slice_size + off > buf_size || !slice_size) {
403                 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
404                 return AVERROR_INVALIDDATA;
405             }
406
407             if ((ret = aic_decode_slice(ctx, x, y,
408                                         buf + off, slice_size)) < 0)
409                 return ret;
410
411             off += slice_size;
412         }
413     }
414
415     *got_frame = 1;
416
417     return avpkt->size;
418 }
419
420 static av_cold int aic_decode_init(AVCodecContext *avctx)
421 {
422     AICContext *ctx = avctx->priv_data;
423     int i;
424     uint8_t scan[64];
425
426     ctx->avctx = avctx;
427
428     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
429
430     ff_idctdsp_init(&ctx->idsp, avctx);
431
432     for (i = 0; i < 64; i++)
433         scan[i] = i;
434     ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
435     for (i = 0; i < 64; i++)
436         ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
437
438     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
439     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
440
441     ctx->num_x_slices = 16;
442     ctx->slice_width  = ctx->mb_width / 16;
443     for (i = 1; i < 32; i++) {
444         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
445             ctx->slice_width  = ctx->mb_width / i;
446             ctx->num_x_slices = i;
447             break;
448         }
449     }
450
451     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
452                                 * sizeof(*ctx->slice_data));
453     if (!ctx->slice_data) {
454         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
455
456         return AVERROR(ENOMEM);
457     }
458
459     for (i = 0; i < NUM_BANDS; i++)
460         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
461                                              * aic_band_off[i];
462
463     return 0;
464 }
465
466 static av_cold int aic_decode_close(AVCodecContext *avctx)
467 {
468     AICContext *ctx = avctx->priv_data;
469
470     av_freep(&ctx->slice_data);
471
472     return 0;
473 }
474
475 AVCodec ff_aic_decoder = {
476     .name           = "aic",
477     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
478     .type           = AVMEDIA_TYPE_VIDEO,
479     .id             = AV_CODEC_ID_AIC,
480     .priv_data_size = sizeof(AICContext),
481     .init           = aic_decode_init,
482     .close          = aic_decode_close,
483     .decode         = aic_decode_frame,
484     .capabilities   = CODEC_CAP_DR1,
485 };