lavc/libaribb24: protect handled value with parenthesis in RGB_TO_BGR
[ffmpeg.git] / libavcodec / imm4.c
1 /*
2  * Infinity IMM4 decoder
3  *
4  * Copyright (c) 2018 Paul B Mahol
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 <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "libavutil/thread.h"
28
29 #include "avcodec.h"
30 #include "bswapdsp.h"
31 #include "copy_block.h"
32 #include "get_bits.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35
36 typedef struct IMM4Context {
37     BswapDSPContext bdsp;
38     GetBitContext  gb;
39
40     AVFrame *prev_frame;
41     uint8_t *bitstream;
42     int bitstream_size;
43
44     int changed_size;
45     int factor;
46     unsigned lo;
47     unsigned hi;
48
49     ScanTable intra_scantable;
50     DECLARE_ALIGNED(32, int16_t, block)[6][64];
51     IDCTDSPContext idsp;
52 } IMM4Context;
53
54 static const uint8_t intra_cb[] = {
55     24, 18, 12
56 };
57
58 static const uint8_t inter_cb[] = {
59     30, 20, 15
60 };
61
62 static const uint8_t cbplo_symbols[] = {
63     3, 4, 19, 20, 35, 36, 51, 52
64 };
65
66 static const uint8_t cbplo_bits[] = {
67     1, 4, 3, 6, 3, 6, 3, 6
68 };
69
70 static const uint8_t cbplo_codes[] = {
71     1, 1, 1, 1, 2, 2, 3, 3
72 };
73
74 static const uint8_t cbphi_bits[] = {
75     4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
76 };
77
78 static const uint8_t cbphi_codes[] = {
79     3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
80 };
81
82 static const uint8_t blktype_symbols[] = {
83     0, 1, 2, 3, 4, 16, 17, 18, 19, 20, 32, 33, 34, 35, 48, 50, 51, 52
84 };
85
86 static const uint8_t blktype_bits[] = {
87     1, 3, 3, 5, 6, 4, 7, 7, 8, 9, 4, 7, 7, 8, 6, 8, 7, 9
88 };
89
90 static const uint8_t blktype_codes[] = {
91     1, 3, 2, 3, 4, 3, 7, 5, 4, 4, 2, 6, 4, 3, 5, 5, 3, 2
92 };
93
94 static const uint16_t block_symbols[] = {
95     0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0x81, 0x82, 0x83,
96     0x84, 0x85, 0x86, 0x101, 0x102, 0x103, 0x104, 0x181, 0x182, 0x183, 0x201, 0x202,
97     0x203, 0x281, 0x282, 0x283, 0x301, 0x302, 0x303, 0x381, 0x382, 0x401, 0x402,
98     0x481, 0x482, 0x501, 0x502, 0x581, 0x601, 0x681, 0x701, 0x781, 0x801, 0x881,
99     0x901, 0x981, 0xA01, 0xA81, 0xB01, 0xB81, 0xC01, 0xC81, 0xD01, 0x4001, 0x4002,
100     0x4003, 0x4081, 0x4082, 0x4101, 0x4181, 0x4201, 0x4281, 0x4301, 0x4381, 0x4401,
101     0x4481, 0x4501, 0x4581, 0x4601, 0x4681, 0x4701, 0x4781, 0x4801, 0x4881, 0x4901,
102     0x4981, 0x4A01, 0x4A81, 0x4B01, 0x4B81, 0x4C01, 0x4C81, 0x4D01, 0x4D81, 0x4E01,
103     0x4E81, 0x4F01, 0x4F81, 0x5001, 0x5081, 0x5101, 0x5181, 0x5201, 0x5281, 0x5301,
104     0x5381, 0x5401
105 };
106
107 static const uint8_t block_bits[] = {
108     7, 2, 4, 6, 7, 8, 9, 9, 10, 10, 11, 11, 11, 3, 6, 8, 10, 11, 12, 4, 8,
109     10, 12, 5, 9, 10, 5, 9, 12, 5, 10, 12, 6, 10, 12, 6, 10, 6, 10, 6,
110     10, 7, 12, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 11, 11, 12, 12, 4, 9,
111     11, 6, 11, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,
112     9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12,
113     12, 12
114 };
115
116 static const uint8_t block_codes[] = {
117     3, 2, 15, 21, 23, 31, 37, 36, 33, 32, 7, 6, 32, 6, 20, 30, 15, 33, 80,
118     14, 29, 14, 81, 13, 35, 13, 12, 34, 82, 11, 12, 83, 19, 11, 84, 18,
119     10, 17, 9, 16, 8, 22, 85, 21, 20, 28, 27, 33, 32, 31, 30, 29, 28,
120     27, 26, 34, 35, 86, 87, 7, 25, 5, 15, 4, 14, 13, 12, 19, 18, 17, 16,
121     26, 25, 24, 23, 22, 21, 20, 19, 24, 23, 22, 21, 20, 19, 18, 17, 7,
122     6, 5, 4, 36, 37, 38, 39, 88, 89, 90, 91, 92, 93, 94, 95
123 };
124
125 static VLC cbplo_tab;
126 static VLC cbphi_tab;
127 static VLC blktype_tab;
128 static VLC block_tab;
129
130 static int get_cbphi(GetBitContext *gb, int x)
131 {
132     int value;
133
134     value = get_vlc2(gb, cbphi_tab.table, cbphi_tab.bits, 1);
135     if (value < 0)
136         return AVERROR_INVALIDDATA;
137
138     return x ? value : 15 - value;
139 }
140
141 static int decode_block(AVCodecContext *avctx, GetBitContext *gb,
142                         int block, int factor, int flag, int offset)
143 {
144     IMM4Context *s = avctx->priv_data;
145     const uint8_t *scantable = s->intra_scantable.permutated;
146     int i, last, len, factor2;
147
148     for (i = !flag; i < 64; i++) {
149         int value;
150
151         value = get_vlc2(gb, block_tab.table, block_tab.bits, 1);
152         if (value < 0)
153             return AVERROR_INVALIDDATA;
154         if (value == 0) {
155             last = get_bits1(gb);
156             len = get_bits(gb, 6);
157             factor2 = get_sbits(gb, 8);
158         } else {
159             factor2 = value & 0x7F;
160             last = (value >> 14) & 1;
161             len = (value >> 7) & 0x3F;
162             if (get_bits1(gb))
163                 factor2 = -factor2;
164         }
165         i += len;
166         if (i >= 64)
167             break;
168         s->block[block][scantable[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
169         if (last)
170             break;
171     }
172
173     return 0;
174 }
175
176 static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb,
177                          unsigned cbp, int flag, int offset)
178 {
179     IMM4Context *s = avctx->priv_data;
180     const uint8_t *scantable = s->intra_scantable.permutated;
181     int ret, i;
182
183     memset(s->block, 0, sizeof(s->block));
184
185     for (i = 0; i < 6; i++) {
186         if (!flag) {
187             int x = get_bits(gb, 8);
188
189             if (x == 255)
190                 x = 128;
191             x *= 8;
192
193             s->block[i][scantable[0]] = x;
194         }
195
196         if (cbp & (1 << (5 - i))) {
197             ret = decode_block(avctx, gb, i, s->factor, flag, offset);
198             if (ret < 0)
199                 return ret;
200         }
201     }
202
203     return 0;
204 }
205
206 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
207 {
208     IMM4Context *s = avctx->priv_data;
209     int ret, x, y, offset = 0;
210
211     if (s->hi == 0) {
212         if (s->lo > 2)
213             return AVERROR_INVALIDDATA;
214         s->factor = intra_cb[s->lo];
215     } else {
216         if (s->hi == 1) {
217             s->factor = s->lo * 2;
218         } else {
219             s->factor = s->lo * 2;
220         }
221     }
222
223     if (s->hi) {
224         offset = s->factor;
225         offset >>= 1;
226         if (!(offset & 1))
227             offset--;
228     }
229
230     for (y = 0; y < avctx->height; y += 16) {
231         for (x = 0; x < avctx->width; x += 16) {
232             unsigned cbphi, cbplo;
233
234             cbplo = get_vlc2(gb, cbplo_tab.table, cbplo_tab.bits, 1) >> 4;
235             skip_bits1(gb);
236
237             cbphi = get_cbphi(gb, 1);
238
239             ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset);
240             if (ret < 0)
241                 return ret;
242
243             s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
244                              frame->linesize[0], s->block[0]);
245             s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
246                              frame->linesize[0], s->block[1]);
247             s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
248                              frame->linesize[0], s->block[2]);
249             s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
250                              frame->linesize[0], s->block[3]);
251             s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
252                              frame->linesize[1], s->block[4]);
253             s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
254                              frame->linesize[2], s->block[5]);
255         }
256     }
257
258     return 0;
259 }
260
261 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
262                         AVFrame *frame, AVFrame *prev)
263 {
264     IMM4Context *s = avctx->priv_data;
265     int ret, x, y, offset = 0;
266
267     if (s->hi == 0) {
268         if (s->lo > 2)
269             return AVERROR_INVALIDDATA;
270         s->factor = inter_cb[s->lo];
271     } else {
272         if (s->hi == 1) {
273             s->factor = s->lo * 2;
274         } else {
275             s->factor = s->lo * 2;
276         }
277     }
278
279     if (s->hi) {
280         offset = s->factor;
281         offset >>= 1;
282         if (!(offset & 1))
283             offset--;
284     }
285
286     for (y = 0; y < avctx->height; y += 16) {
287         for (x = 0; x < avctx->width; x += 16) {
288             int reverse, intra_block, value;
289             unsigned cbphi, cbplo;
290
291             if (get_bits1(gb)) {
292                 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
293                              prev->data[0] + y * prev->linesize[0] + x,
294                              frame->linesize[0], prev->linesize[0], 16);
295                 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
296                             prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
297                             frame->linesize[1], prev->linesize[1], 8);
298                 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
299                             prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
300                             frame->linesize[2], prev->linesize[2], 8);
301                 continue;
302             }
303
304             value = get_vlc2(gb, blktype_tab.table, blktype_tab.bits, 1);
305             if (value < 0)
306                 return AVERROR_INVALIDDATA;
307
308             intra_block = value & 0x07;
309             reverse = intra_block == 3;
310             if (reverse)
311                 skip_bits1(gb);
312
313             cbplo = value >> 4;
314             cbphi = get_cbphi(gb, reverse);
315             if (intra_block) {
316                 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset);
317                 if (ret < 0)
318                     return ret;
319
320                 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
321                                  frame->linesize[0], s->block[0]);
322                 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
323                                  frame->linesize[0], s->block[1]);
324                 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
325                                  frame->linesize[0], s->block[2]);
326                 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
327                                  frame->linesize[0], s->block[3]);
328                 s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
329                                  frame->linesize[1], s->block[4]);
330                 s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
331                                  frame->linesize[2], s->block[5]);
332             } else {
333                 skip_bits(gb, 2);
334                 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset);
335                 if (ret < 0)
336                     return ret;
337
338                 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
339                              prev->data[0] + y * prev->linesize[0] + x,
340                              frame->linesize[0], prev->linesize[0], 16);
341                 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
342                             prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
343                             frame->linesize[1], prev->linesize[1], 8);
344                 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
345                             prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
346                             frame->linesize[2], prev->linesize[2], 8);
347
348                 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
349                                  frame->linesize[0], s->block[0]);
350                 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
351                                  frame->linesize[0], s->block[1]);
352                 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
353                                  frame->linesize[0], s->block[2]);
354                 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
355                                  frame->linesize[0], s->block[3]);
356                 s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
357                                  frame->linesize[1], s->block[4]);
358                 s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
359                                  frame->linesize[2], s->block[5]);
360             }
361         }
362     }
363
364     return 0;
365 }
366
367 static int decode_frame(AVCodecContext *avctx, void *data,
368                         int *got_frame, AVPacket *avpkt)
369 {
370     IMM4Context *s = avctx->priv_data;
371     GetBitContext *gb = &s->gb;
372     AVFrame *frame = data;
373     unsigned type;
374     int ret, scaled;
375
376     if (avpkt->size <= 32)
377         return AVERROR_INVALIDDATA;
378
379     av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
380                           FFALIGN(avpkt->size, 4));
381     if (!s->bitstream)
382         return AVERROR(ENOMEM);
383
384     s->bdsp.bswap_buf((uint32_t *)s->bitstream,
385                       (uint32_t *)avpkt->data,
386                       (avpkt->size + 3) >> 2);
387
388     if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
389         return ret;
390
391     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
392     avctx->color_range = AVCOL_RANGE_JPEG;
393
394     scaled = avpkt->data[8];
395     if (scaled < 2) {
396         int width, height;
397         int mode = avpkt->data[10];
398
399         switch (mode) {
400         case 1:
401             width = 352;
402             height = 240;
403             break;
404         case 2:
405             width = 704;
406             height = 240;
407             break;
408         case 4:
409             width = 480;
410             height = 704;
411             break;
412         case 17:
413             width = 352;
414             height = 288;
415             break;
416         case 18:
417             width = 704;
418             height = 288;
419             break;
420         default:
421             width = 704;
422             height = 576;
423             break;
424         }
425
426         if (s->changed_size == 1 &&
427             (avctx->width != width || avctx->height != height)) {
428             av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
429             return AVERROR_INVALIDDATA;
430         }
431         ret = ff_set_dimensions(avctx, width, height);
432         if (ret < 0)
433             return ret;
434     }
435
436     s->changed_size = 1;
437     skip_bits_long(gb, 24 * 8);
438     type = get_bits_long(gb, 32);
439     s->hi = get_bits(gb, 16);
440     s->lo = get_bits(gb, 16);
441
442     switch (type) {
443     case 0x19781977:
444         frame->key_frame = 1;
445         frame->pict_type = AV_PICTURE_TYPE_I;
446         break;
447     case 0x12250926:
448         frame->key_frame = 0;
449         frame->pict_type = AV_PICTURE_TYPE_P;
450         break;
451     default:
452         avpriv_request_sample(avctx, "type %X", type);
453         return AVERROR_PATCHWELCOME;
454     }
455
456     if ((ret = ff_get_buffer(avctx, frame, frame->key_frame ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
457         return ret;
458
459     if (frame->key_frame) {
460         ret = decode_intra(avctx, gb, frame);
461         if (ret < 0)
462             return ret;
463
464         av_frame_unref(s->prev_frame);
465         if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
466             return ret;
467     } else {
468         if (!s->prev_frame->data[0]) {
469             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
470             return AVERROR_INVALIDDATA;
471         }
472
473         ret = decode_inter(avctx, gb, frame, s->prev_frame);
474         if (ret < 0)
475             return ret;
476     }
477
478     *got_frame = 1;
479
480     return avpkt->size;
481 }
482
483 static av_cold void imm4_init_static_data(void)
484 {
485     INIT_VLC_SPARSE_STATIC(&cbplo_tab, 9, FF_ARRAY_ELEMS(cbplo_bits),
486                            cbplo_bits, 1, 1, cbplo_codes, 1, 1, cbplo_symbols, 1, 1, 512);
487
488     INIT_VLC_SPARSE_STATIC(&cbphi_tab, 6, FF_ARRAY_ELEMS(cbphi_bits),
489                            cbphi_bits, 1, 1, cbphi_codes, 1, 1, NULL, 0, 0, 64);
490
491     INIT_VLC_SPARSE_STATIC(&blktype_tab, 9, FF_ARRAY_ELEMS(blktype_bits),
492                            blktype_bits, 1, 1, blktype_codes, 1, 1, blktype_symbols, 1, 1, 512);
493
494     INIT_VLC_SPARSE_STATIC(&block_tab, 12, FF_ARRAY_ELEMS(block_bits),
495                            block_bits, 1, 1, block_codes, 1, 1, block_symbols, 2, 2, 4096);
496 }
497
498 static av_cold int decode_init(AVCodecContext *avctx)
499 {
500     static AVOnce init_static_once = AV_ONCE_INIT;
501     IMM4Context *s = avctx->priv_data;
502     uint8_t table[64];
503
504     for (int i = 0; i < 64; i++)
505         table[i] = i;
506
507     ff_bswapdsp_init(&s->bdsp);
508     ff_idctdsp_init(&s->idsp, avctx);
509     ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, table);
510
511     s->prev_frame = av_frame_alloc();
512     if (!s->prev_frame)
513         return AVERROR(ENOMEM);
514
515     ff_thread_once(&init_static_once, imm4_init_static_data);
516
517     return 0;
518 }
519
520 static av_cold int decode_close(AVCodecContext *avctx)
521 {
522     IMM4Context *s = avctx->priv_data;
523
524     av_frame_free(&s->prev_frame);
525     av_freep(&s->bitstream);
526     s->bitstream_size = 0;
527
528     return 0;
529 }
530
531 AVCodec ff_imm4_decoder = {
532     .name             = "imm4",
533     .long_name        = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
534     .type             = AVMEDIA_TYPE_VIDEO,
535     .id               = AV_CODEC_ID_IMM4,
536     .priv_data_size   = sizeof(IMM4Context),
537     .init             = decode_init,
538     .close            = decode_close,
539     .decode           = decode_frame,
540     .capabilities     = AV_CODEC_CAP_DR1,
541     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
542                         FF_CODEC_CAP_INIT_CLEANUP,
543 };