2 * Infinity IMM4 decoder
4 * Copyright (c) 2018 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/mem_internal.h"
28 #include "libavutil/thread.h"
32 #include "copy_block.h"
37 #define CBPLO_VLC_BITS 6
38 #define CBPHI_VLC_BITS 6
39 #define BLKTYPE_VLC_BITS 9
40 #define BLOCK_VLC_BITS 12
42 typedef struct IMM4Context {
54 ScanTable intra_scantable;
55 DECLARE_ALIGNED(32, int16_t, block)[6][64];
59 static const uint8_t intra_cb[] = {
63 static const uint8_t inter_cb[] = {
67 static const uint8_t cbplo[][2] = {
68 { 0,-6 }, { 0x01, 6 }, { 0x02, 6 }, { 0x03, 6 }, { 0x00, 4 },
69 { 0x01, 3 }, { 0x02, 3 }, { 0x03, 3 }, { 0x00, 1 },
72 static const uint8_t cbphi_bits[] = {
73 4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
76 static const uint8_t cbphi_codes[] = {
77 3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
80 static const uint8_t blktype[][2] = {
81 { 0,-8 }, { 0x34, 9 }, { 0,-9 }, { 0x14, 9 }, { 0,-9 },
82 { 0x23, 8 }, { 0x13, 8 }, { 0x32, 8 }, { 0x33, 7 }, { 0x22, 7 },
83 { 0x12, 7 }, { 0x21, 7 }, { 0x11, 7 }, { 0x04, 6 }, { 0x30, 6 },
84 { 0x03, 5 }, { 0x20, 4 }, { 0x10, 4 }, { 0x02, 3 }, { 0x01, 3 },
88 static const uint16_t block_symbols[] = {
89 0, 0x4082, 0x4003, 0x000B, 0x000A, 0x4E01, 0x4D81, 0x4D01, 0x4C81,
90 0x0482, 0x0402, 0x0382, 0x0302, 0x0282, 0x0183, 0x0103, 0x0084, 0x000C,
91 0x0085, 0x0B81, 0x0C01, 0x4E81, 0x4F01, 0x4F81, 0x5001, 0x0086, 0x0104,
92 0x0203, 0x0283, 0x0303, 0x0502, 0x0C81, 0x0D01, 0x5081, 0x5101, 0x5181,
93 0x5201, 0x5281, 0x5301, 0x5381, 0x5401, 0x0000, 0x0009, 0x0008, 0x4C01,
94 0x4B81, 0x4B01, 0x4A81, 0x4A01, 0x4981, 0x4901, 0x4881, 0x4002, 0x0B01,
95 0x0A81, 0x0A01, 0x0981, 0x0901, 0x0881, 0x0801, 0x0781, 0x0202, 0x0182,
96 0x0007, 0x0006, 0x4801, 0x4781, 0x4701, 0x4681, 0x4601, 0x4581, 0x4501,
97 0x4481, 0x0701, 0x0681, 0x0102, 0x0083, 0x0005, 0x4401, 0x4381, 0x4301,
98 0x4281, 0x0601, 0x0581, 0x0501, 0x0004, 0x4201, 0x4181, 0x4101, 0x4081,
99 0x0481, 0x0401, 0x0381, 0x0301, 0x0082, 0x0003, 0x0281, 0x0201, 0x0181,
100 0x4001, 0x0001, 0x0081, 0x0101, 0x0002,
103 static const uint8_t block_bits[] = {
104 -9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11,
105 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
106 12, 12, 12, 7, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
107 9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
108 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6,
109 6, 5, 5, 5, 4, 2, 3, 4, 4,
112 static VLC cbplo_tab;
113 static VLC cbphi_tab;
114 static VLC blktype_tab;
115 static VLC block_tab;
117 static int get_cbphi(GetBitContext *gb, int x)
121 value = get_vlc2(gb, cbphi_tab.table, CBPHI_VLC_BITS, 1);
123 return AVERROR_INVALIDDATA;
125 return x ? value : 15 - value;
128 static int decode_block(AVCodecContext *avctx, GetBitContext *gb,
129 int block, int factor, int flag, int offset, int flag2)
131 IMM4Context *s = avctx->priv_data;
132 const uint8_t *scantable = s->intra_scantable.permutated;
133 int i, last, len, factor2;
135 for (i = !flag; i < 64; i++) {
138 value = get_vlc2(gb, block_tab.table, BLOCK_VLC_BITS, 1);
140 return AVERROR_INVALIDDATA;
142 last = get_bits1(gb);
143 len = get_bits(gb, 6);
144 factor2 = get_sbits(gb, 8);
146 factor2 = value & 0x7F;
147 last = (value >> 14) & 1;
148 len = (value >> 7) & 0x3F;
155 s->block[block][scantable[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
160 if (s->hi == 2 && flag2 && block < 4) {
162 s->block[block][scantable[0]] *= 2;
163 s->block[block][scantable[1]] *= 2;
164 s->block[block][scantable[8]] *= 2;
165 s->block[block][scantable[16]] *= 2;
171 static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb,
172 unsigned cbp, int flag, int offset, unsigned flag2)
174 IMM4Context *s = avctx->priv_data;
175 const uint8_t *scantable = s->intra_scantable.permutated;
178 memset(s->block, 0, sizeof(s->block));
180 for (i = 0; i < 6; i++) {
182 int x = get_bits(gb, 8);
188 s->block[i][scantable[0]] = x;
191 if (cbp & (1 << (5 - i))) {
192 ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
201 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
203 IMM4Context *s = avctx->priv_data;
204 int ret, x, y, offset = 0;
208 return AVERROR_INVALIDDATA;
209 s->factor = intra_cb[s->lo];
211 s->factor = s->lo * 2;
221 for (y = 0; y < avctx->height; y += 16) {
222 for (x = 0; x < avctx->width; x += 16) {
223 unsigned flag, cbphi, cbplo;
225 cbplo = get_vlc2(gb, cbplo_tab.table, CBPLO_VLC_BITS, 1);
226 flag = get_bits1(gb);
228 cbphi = get_cbphi(gb, 1);
230 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
234 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
235 frame->linesize[0], s->block[0]);
236 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
237 frame->linesize[0], s->block[1]);
238 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
239 frame->linesize[0], s->block[2]);
240 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
241 frame->linesize[0], s->block[3]);
242 s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
243 frame->linesize[1], s->block[4]);
244 s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
245 frame->linesize[2], s->block[5]);
252 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
253 AVFrame *frame, AVFrame *prev)
255 IMM4Context *s = avctx->priv_data;
256 int ret, x, y, offset = 0;
260 return AVERROR_INVALIDDATA;
261 s->factor = inter_cb[s->lo];
263 s->factor = s->lo * 2;
273 for (y = 0; y < avctx->height; y += 16) {
274 for (x = 0; x < avctx->width; x += 16) {
275 int reverse, intra_block, value;
276 unsigned cbphi, cbplo, flag2 = 0;
279 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
280 prev->data[0] + y * prev->linesize[0] + x,
281 frame->linesize[0], prev->linesize[0], 16);
282 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
283 prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
284 frame->linesize[1], prev->linesize[1], 8);
285 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
286 prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
287 frame->linesize[2], prev->linesize[2], 8);
291 value = get_vlc2(gb, blktype_tab.table, BLKTYPE_VLC_BITS, 1);
293 return AVERROR_INVALIDDATA;
295 intra_block = value & 0x07;
296 reverse = intra_block == 3;
298 flag2 = get_bits1(gb);
301 cbphi = get_cbphi(gb, reverse);
303 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
307 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
308 frame->linesize[0], s->block[0]);
309 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
310 frame->linesize[0], s->block[1]);
311 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
312 frame->linesize[0], s->block[2]);
313 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
314 frame->linesize[0], s->block[3]);
315 s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
316 frame->linesize[1], s->block[4]);
317 s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
318 frame->linesize[2], s->block[5]);
320 flag2 = get_bits1(gb);
322 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
326 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
327 prev->data[0] + y * prev->linesize[0] + x,
328 frame->linesize[0], prev->linesize[0], 16);
329 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
330 prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
331 frame->linesize[1], prev->linesize[1], 8);
332 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
333 prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
334 frame->linesize[2], prev->linesize[2], 8);
336 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
337 frame->linesize[0], s->block[0]);
338 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
339 frame->linesize[0], s->block[1]);
340 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
341 frame->linesize[0], s->block[2]);
342 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
343 frame->linesize[0], s->block[3]);
344 s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
345 frame->linesize[1], s->block[4]);
346 s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
347 frame->linesize[2], s->block[5]);
355 static int decode_frame(AVCodecContext *avctx, void *data,
356 int *got_frame, AVPacket *avpkt)
358 IMM4Context *s = avctx->priv_data;
359 GetBitContext *gb = &s->gb;
360 AVFrame *frame = data;
365 if (avpkt->size <= 32)
366 return AVERROR_INVALIDDATA;
368 av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
369 FFALIGN(avpkt->size, 4));
371 return AVERROR(ENOMEM);
373 s->bdsp.bswap_buf((uint32_t *)s->bitstream,
374 (uint32_t *)avpkt->data,
375 (avpkt->size + 3) >> 2);
377 if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
380 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
381 avctx->color_range = AVCOL_RANGE_JPEG;
383 width = avctx->width;
384 height = avctx->height;
386 scaled = avpkt->data[8];
388 int mode = avpkt->data[10];
418 skip_bits_long(gb, 24 * 8);
419 type = get_bits_long(gb, 32);
420 s->hi = get_bits(gb, 16);
421 s->lo = get_bits(gb, 16);
425 frame->key_frame = 1;
426 frame->pict_type = AV_PICTURE_TYPE_I;
429 frame->key_frame = 0;
430 frame->pict_type = AV_PICTURE_TYPE_P;
433 avpriv_request_sample(avctx, "type %X", type);
434 return AVERROR_PATCHWELCOME;
437 if (avctx->width != width ||
438 avctx->height != height) {
439 if (!frame->key_frame) {
440 av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
441 return AVERROR_INVALIDDATA;
443 av_frame_unref(s->prev_frame);
446 ret = ff_set_dimensions(avctx, width, height);
450 if ((ret = ff_get_buffer(avctx, frame, frame->key_frame ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
453 if (frame->key_frame) {
454 ret = decode_intra(avctx, gb, frame);
458 av_frame_unref(s->prev_frame);
459 if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
462 if (!s->prev_frame->data[0]) {
463 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
464 return AVERROR_INVALIDDATA;
467 ret = decode_inter(avctx, gb, frame, s->prev_frame);
477 static av_cold void imm4_init_static_data(void)
479 INIT_VLC_STATIC_FROM_LENGTHS(&cbplo_tab, CBPLO_VLC_BITS, FF_ARRAY_ELEMS(cbplo),
480 &cbplo[0][1], 2, &cbplo[0][0], 2, 1,
481 0, 0, 1 << CBPLO_VLC_BITS);
483 INIT_VLC_SPARSE_STATIC(&cbphi_tab, CBPHI_VLC_BITS, FF_ARRAY_ELEMS(cbphi_bits),
484 cbphi_bits, 1, 1, cbphi_codes, 1, 1, NULL, 0, 0, 64);
486 INIT_VLC_STATIC_FROM_LENGTHS(&blktype_tab, BLKTYPE_VLC_BITS, FF_ARRAY_ELEMS(blktype),
487 &blktype[0][1], 2, &blktype[0][0], 2, 1,
488 0, 0, 1 << BLKTYPE_VLC_BITS);
490 INIT_VLC_STATIC_FROM_LENGTHS(&block_tab, BLOCK_VLC_BITS, FF_ARRAY_ELEMS(block_bits),
491 block_bits, 1, block_symbols, 2, 2,
492 0, 0, 1 << BLOCK_VLC_BITS);
495 static av_cold int decode_init(AVCodecContext *avctx)
497 static AVOnce init_static_once = AV_ONCE_INIT;
498 IMM4Context *s = avctx->priv_data;
501 for (int i = 0; i < 64; i++)
504 ff_bswapdsp_init(&s->bdsp);
505 ff_idctdsp_init(&s->idsp, avctx);
506 ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, table);
508 s->prev_frame = av_frame_alloc();
510 return AVERROR(ENOMEM);
512 ff_thread_once(&init_static_once, imm4_init_static_data);
517 static void decode_flush(AVCodecContext *avctx)
519 IMM4Context *s = avctx->priv_data;
521 av_frame_unref(s->prev_frame);
524 static av_cold int decode_close(AVCodecContext *avctx)
526 IMM4Context *s = avctx->priv_data;
528 av_frame_free(&s->prev_frame);
529 av_freep(&s->bitstream);
530 s->bitstream_size = 0;
535 AVCodec ff_imm4_decoder = {
537 .long_name = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
538 .type = AVMEDIA_TYPE_VIDEO,
539 .id = AV_CODEC_ID_IMM4,
540 .priv_data_size = sizeof(IMM4Context),
542 .close = decode_close,
543 .decode = decode_frame,
544 .flush = decode_flush,
545 .capabilities = AV_CODEC_CAP_DR1,
546 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
547 FF_CODEC_CAP_INIT_CLEANUP,