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