git.sesse.net Git - ffmpeg/blob - 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 #define CBPLO_VLC_BITS   6
  37 #define CBPHI_VLC_BITS   6
  38 #define BLKTYPE_VLC_BITS 9
  39 #define BLOCK_VLC_BITS  12
  40
  41 typedef struct IMM4Context {
  42     BswapDSPContext bdsp;
  43     GetBitContext  gb;
  44
  45     AVFrame *prev_frame;
  46     uint8_t *bitstream;
  47     int bitstream_size;
  48
  49     int factor;
  50     unsigned lo;
  51     unsigned hi;
  52
  53     ScanTable intra_scantable;
  54     DECLARE_ALIGNED(32, int16_t, block)[6][64];
  55     IDCTDSPContext idsp;
  56 } IMM4Context;
  57
  58 static const uint8_t intra_cb[] = {
  59     24, 18, 12
  60 };
  61
  62 static const uint8_t inter_cb[] = {
  63     30, 20, 15
  64 };
  65
  66 static const uint8_t cbplo[][2] = {
  67     {    0,-6 }, { 0x01, 6 }, { 0x02, 6 }, { 0x03, 6 }, { 0x00, 4 },
  68     { 0x01, 3 }, { 0x02, 3 }, { 0x03, 3 }, { 0x00, 1 },
  69 };
  70
  71 static const uint8_t cbphi_bits[] = {
  72     4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
  73 };
  74
  75 static const uint8_t cbphi_codes[] = {
  76     3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
  77 };
  78
  79 static const uint8_t blktype[][2] = {
  80     {    0,-8 }, { 0x34, 9 }, {    0,-9 }, { 0x14, 9 }, {    0,-9 },
  81     { 0x23, 8 }, { 0x13, 8 }, { 0x32, 8 }, { 0x33, 7 }, { 0x22, 7 },
  82     { 0x12, 7 }, { 0x21, 7 }, { 0x11, 7 }, { 0x04, 6 }, { 0x30, 6 },
  83     { 0x03, 5 }, { 0x20, 4 }, { 0x10, 4 }, { 0x02, 3 }, { 0x01, 3 },
  84     { 0x00, 1 },
  85 };
  86
  87 static const uint16_t block_symbols[] = {
  88          0, 0x4082, 0x4003, 0x000B, 0x000A, 0x4E01, 0x4D81, 0x4D01, 0x4C81,
  89     0x0482, 0x0402, 0x0382, 0x0302, 0x0282, 0x0183, 0x0103, 0x0084, 0x000C,
  90     0x0085, 0x0B81, 0x0C01, 0x4E81, 0x4F01, 0x4F81, 0x5001, 0x0086, 0x0104,
  91     0x0203, 0x0283, 0x0303, 0x0502, 0x0C81, 0x0D01, 0x5081, 0x5101, 0x5181,
  92     0x5201, 0x5281, 0x5301, 0x5381, 0x5401, 0x0000, 0x0009, 0x0008, 0x4C01,
  93     0x4B81, 0x4B01, 0x4A81, 0x4A01, 0x4981, 0x4901, 0x4881, 0x4002, 0x0B01,
  94     0x0A81, 0x0A01, 0x0981, 0x0901, 0x0881, 0x0801, 0x0781, 0x0202, 0x0182,
  95     0x0007, 0x0006, 0x4801, 0x4781, 0x4701, 0x4681, 0x4601, 0x4581, 0x4501,
  96     0x4481, 0x0701, 0x0681, 0x0102, 0x0083, 0x0005, 0x4401, 0x4381, 0x4301,
  97     0x4281, 0x0601, 0x0581, 0x0501, 0x0004, 0x4201, 0x4181, 0x4101, 0x4081,
  98     0x0481, 0x0401, 0x0381, 0x0301, 0x0082, 0x0003, 0x0281, 0x0201, 0x0181,
  99     0x4001, 0x0001, 0x0081, 0x0101, 0x0002,
 100 };
 101
 102 static const uint8_t block_bits[] = {
 103     -9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11,
 104     11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
 105     12, 12, 12,  7, 10, 10,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
 106      9,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
 107      8,  8,  7,  7,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,  6,  6,
 108      6,  5,  5,  5,  4,  2,  3,  4,  4,
 109 };
 110
 111 static VLC cbplo_tab;
 112 static VLC cbphi_tab;
 113 static VLC blktype_tab;
 114 static VLC block_tab;
 115
 116 static int get_cbphi(GetBitContext *gb, int x)
 117 {
 118     int value;
 119
 120     value = get_vlc2(gb, cbphi_tab.table, CBPHI_VLC_BITS, 1);
 121     if (value < 0)
 122         return AVERROR_INVALIDDATA;
 123
 124     return x ? value : 15 - value;
 125 }
 126
 127 static int decode_block(AVCodecContext *avctx, GetBitContext *gb,
 128                         int block, int factor, int flag, int offset, int flag2)
 129 {
 130     IMM4Context *s = avctx->priv_data;
 131     const uint8_t *scantable = s->intra_scantable.permutated;
 132     int i, last, len, factor2;
 133
 134     for (i = !flag; i < 64; i++) {
 135         int value;
 136
 137         value = get_vlc2(gb, block_tab.table, BLOCK_VLC_BITS, 1);
 138         if (value < 0)
 139             return AVERROR_INVALIDDATA;
 140         if (value == 0) {
 141             last = get_bits1(gb);
 142             len = get_bits(gb, 6);
 143             factor2 = get_sbits(gb, 8);
 144         } else {
 145             factor2 = value & 0x7F;
 146             last = (value >> 14) & 1;
 147             len = (value >> 7) & 0x3F;
 148             if (get_bits1(gb))
 149                 factor2 = -factor2;
 150         }
 151         i += len;
 152         if (i >= 64)
 153             break;
 154         s->block[block][scantable[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
 155         if (last)
 156             break;
 157     }
 158
 159     if (s->hi == 2 && flag2 && block < 4) {
 160         if (flag)
 161             s->block[block][scantable[0]]  *= 2;
 162         s->block[block][scantable[1]]  *= 2;
 163         s->block[block][scantable[8]]  *= 2;
 164         s->block[block][scantable[16]] *= 2;
 165     }
 166
 167     return 0;
 168 }
 169
 170 static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb,
 171                          unsigned cbp, int flag, int offset, unsigned flag2)
 172 {
 173     IMM4Context *s = avctx->priv_data;
 174     const uint8_t *scantable = s->intra_scantable.permutated;
 175     int ret, i;
 176
 177     memset(s->block, 0, sizeof(s->block));
 178
 179     for (i = 0; i < 6; i++) {
 180         if (!flag) {
 181             int x = get_bits(gb, 8);
 182
 183             if (x == 255)
 184                 x = 128;
 185             x *= 8;
 186
 187             s->block[i][scantable[0]] = x;
 188         }
 189
 190         if (cbp & (1 << (5 - i))) {
 191             ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
 192             if (ret < 0)
 193                 return ret;
 194         }
 195     }
 196
 197     return 0;
 198 }
 199
 200 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
 201 {
 202     IMM4Context *s = avctx->priv_data;
 203     int ret, x, y, offset = 0;
 204
 205     if (s->hi == 0) {
 206         if (s->lo > 2)
 207             return AVERROR_INVALIDDATA;
 208         s->factor = intra_cb[s->lo];
 209     } else {
 210         s->factor = s->lo * 2;
 211     }
 212
 213     if (s->hi) {
 214         offset = s->factor;
 215         offset >>= 1;
 216         if (!(offset & 1))
 217             offset--;
 218     }
 219
 220     for (y = 0; y < avctx->height; y += 16) {
 221         for (x = 0; x < avctx->width; x += 16) {
 222             unsigned flag, cbphi, cbplo;
 223
 224             cbplo = get_vlc2(gb, cbplo_tab.table, CBPLO_VLC_BITS, 1);
 225             flag = get_bits1(gb);
 226
 227             cbphi = get_cbphi(gb, 1);
 228
 229             ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
 230             if (ret < 0)
 231                 return ret;
 232
 233             s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
 234                              frame->linesize[0], s->block[0]);
 235             s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
 236                              frame->linesize[0], s->block[1]);
 237             s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
 238                              frame->linesize[0], s->block[2]);
 239             s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
 240                              frame->linesize[0], s->block[3]);
 241             s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
 242                              frame->linesize[1], s->block[4]);
 243             s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
 244                              frame->linesize[2], s->block[5]);
 245         }
 246     }
 247
 248     return 0;
 249 }
 250
 251 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
 252                         AVFrame *frame, AVFrame *prev)
 253 {
 254     IMM4Context *s = avctx->priv_data;
 255     int ret, x, y, offset = 0;
 256
 257     if (s->hi == 0) {
 258         if (s->lo > 2)
 259             return AVERROR_INVALIDDATA;
 260         s->factor = inter_cb[s->lo];
 261     } else {
 262         s->factor = s->lo * 2;
 263     }
 264
 265     if (s->hi) {
 266         offset = s->factor;
 267         offset >>= 1;
 268         if (!(offset & 1))
 269             offset--;
 270     }
 271
 272     for (y = 0; y < avctx->height; y += 16) {
 273         for (x = 0; x < avctx->width; x += 16) {
 274             int reverse, intra_block, value;
 275             unsigned cbphi, cbplo, flag2 = 0;
 276
 277             if (get_bits1(gb)) {
 278                 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
 279                              prev->data[0] + y * prev->linesize[0] + x,
 280                              frame->linesize[0], prev->linesize[0], 16);
 281                 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
 282                             prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
 283                             frame->linesize[1], prev->linesize[1], 8);
 284                 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
 285                             prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
 286                             frame->linesize[2], prev->linesize[2], 8);
 287                 continue;
 288             }
 289
 290             value = get_vlc2(gb, blktype_tab.table, BLKTYPE_VLC_BITS, 1);
 291             if (value < 0)
 292                 return AVERROR_INVALIDDATA;
 293
 294             intra_block = value & 0x07;
 295             reverse = intra_block == 3;
 296             if (reverse)
 297                 flag2 = get_bits1(gb);
 298
 299             cbplo = value >> 4;
 300             cbphi = get_cbphi(gb, reverse);
 301             if (intra_block) {
 302                 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
 303                 if (ret < 0)
 304                     return ret;
 305
 306                 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
 307                                  frame->linesize[0], s->block[0]);
 308                 s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
 309                                  frame->linesize[0], s->block[1]);
 310                 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
 311                                  frame->linesize[0], s->block[2]);
 312                 s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
 313                                  frame->linesize[0], s->block[3]);
 314                 s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
 315                                  frame->linesize[1], s->block[4]);
 316                 s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
 317                                  frame->linesize[2], s->block[5]);
 318             } else {
 319                 flag2 = get_bits1(gb);
 320                 skip_bits1(gb);
 321                 ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
 322                 if (ret < 0)
 323                     return ret;
 324
 325                 copy_block16(frame->data[0] + y * frame->linesize[0] + x,
 326                              prev->data[0] + y * prev->linesize[0] + x,
 327                              frame->linesize[0], prev->linesize[0], 16);
 328                 copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
 329                             prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
 330                             frame->linesize[1], prev->linesize[1], 8);
 331                 copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
 332                             prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
 333                             frame->linesize[2], prev->linesize[2], 8);
 334
 335                 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
 336                                  frame->linesize[0], s->block[0]);
 337                 s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
 338                                  frame->linesize[0], s->block[1]);
 339                 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
 340                                  frame->linesize[0], s->block[2]);
 341                 s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
 342                                  frame->linesize[0], s->block[3]);
 343                 s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
 344                                  frame->linesize[1], s->block[4]);
 345                 s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
 346                                  frame->linesize[2], s->block[5]);
 347             }
 348         }
 349     }
 350
 351     return 0;
 352 }
 353
 354 static int decode_frame(AVCodecContext *avctx, void *data,
 355                         int *got_frame, AVPacket *avpkt)
 356 {
 357     IMM4Context *s = avctx->priv_data;
 358     GetBitContext *gb = &s->gb;
 359     AVFrame *frame = data;
 360     int width, height;
 361     unsigned type;
 362     int ret, scaled;
 363
 364     if (avpkt->size <= 32)
 365         return AVERROR_INVALIDDATA;
 366
 367     av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
 368                           FFALIGN(avpkt->size, 4));
 369     if (!s->bitstream)
 370         return AVERROR(ENOMEM);
 371
 372     s->bdsp.bswap_buf((uint32_t *)s->bitstream,
 373                       (uint32_t *)avpkt->data,
 374                       (avpkt->size + 3) >> 2);
 375
 376     if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
 377         return ret;
 378
 379     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 380     avctx->color_range = AVCOL_RANGE_JPEG;
 381
 382     width = avctx->width;
 383     height = avctx->height;
 384
 385     scaled = avpkt->data[8];
 386     if (scaled < 2) {
 387         int mode = avpkt->data[10];
 388
 389         switch (mode) {
 390         case 1:
 391             width = 352;
 392             height = 240;
 393             break;
 394         case 2:
 395             width = 704;
 396             height = 240;
 397             break;
 398         case 4:
 399             width = 480;
 400             height = 704;
 401             break;
 402         case 17:
 403             width = 352;
 404             height = 288;
 405             break;
 406         case 18:
 407             width = 704;
 408             height = 288;
 409             break;
 410         default:
 411             width = 704;
 412             height = 576;
 413             break;
 414         }
 415     }
 416
 417     skip_bits_long(gb, 24 * 8);
 418     type = get_bits_long(gb, 32);
 419     s->hi = get_bits(gb, 16);
 420     s->lo = get_bits(gb, 16);
 421
 422     switch (type) {
 423     case 0x19781977:
 424         frame->key_frame = 1;
 425         frame->pict_type = AV_PICTURE_TYPE_I;
 426         break;
 427     case 0x12250926:
 428         frame->key_frame = 0;
 429         frame->pict_type = AV_PICTURE_TYPE_P;
 430         break;
 431     default:
 432         avpriv_request_sample(avctx, "type %X", type);
 433         return AVERROR_PATCHWELCOME;
 434     }
 435
 436     if (avctx->width  != width ||
 437         avctx->height != height) {
 438         if (!frame->key_frame) {
 439             av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
 440             return AVERROR_INVALIDDATA;
 441         }
 442         av_frame_unref(s->prev_frame);
 443     }
 444
 445     ret = ff_set_dimensions(avctx, width, height);
 446     if (ret < 0)
 447         return ret;
 448
 449     if ((ret = ff_get_buffer(avctx, frame, frame->key_frame ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
 450         return ret;
 451
 452     if (frame->key_frame) {
 453         ret = decode_intra(avctx, gb, frame);
 454         if (ret < 0)
 455             return ret;
 456
 457         av_frame_unref(s->prev_frame);
 458         if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
 459             return ret;
 460     } else {
 461         if (!s->prev_frame->data[0]) {
 462             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
 463             return AVERROR_INVALIDDATA;
 464         }
 465
 466         ret = decode_inter(avctx, gb, frame, s->prev_frame);
 467         if (ret < 0)
 468             return ret;
 469     }
 470
 471     *got_frame = 1;
 472
 473     return avpkt->size;
 474 }
 475
 476 static av_cold void imm4_init_static_data(void)
 477 {
 478     INIT_VLC_STATIC_FROM_LENGTHS(&cbplo_tab, CBPLO_VLC_BITS, FF_ARRAY_ELEMS(cbplo),
 479                                  &cbplo[0][1], 2, &cbplo[0][0], 2, 1,
 480                                  0, 0, 1 << CBPLO_VLC_BITS);
 481
 482     INIT_VLC_SPARSE_STATIC(&cbphi_tab, CBPHI_VLC_BITS, FF_ARRAY_ELEMS(cbphi_bits),
 483                            cbphi_bits, 1, 1, cbphi_codes, 1, 1, NULL, 0, 0, 64);
 484
 485     INIT_VLC_STATIC_FROM_LENGTHS(&blktype_tab, BLKTYPE_VLC_BITS, FF_ARRAY_ELEMS(blktype),
 486                                  &blktype[0][1], 2, &blktype[0][0], 2, 1,
 487                                  0, 0, 1 << BLKTYPE_VLC_BITS);
 488
 489     INIT_VLC_STATIC_FROM_LENGTHS(&block_tab, BLOCK_VLC_BITS, FF_ARRAY_ELEMS(block_bits),
 490                                  block_bits, 1, block_symbols, 2, 2,
 491                                  0, 0, 1 << BLOCK_VLC_BITS);
 492 }
 493
 494 static av_cold int decode_init(AVCodecContext *avctx)
 495 {
 496     static AVOnce init_static_once = AV_ONCE_INIT;
 497     IMM4Context *s = avctx->priv_data;
 498     uint8_t table[64];
 499
 500     for (int i = 0; i < 64; i++)
 501         table[i] = i;
 502
 503     ff_bswapdsp_init(&s->bdsp);
 504     ff_idctdsp_init(&s->idsp, avctx);
 505     ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, table);
 506
 507     s->prev_frame = av_frame_alloc();
 508     if (!s->prev_frame)
 509         return AVERROR(ENOMEM);
 510
 511     ff_thread_once(&init_static_once, imm4_init_static_data);
 512
 513     return 0;
 514 }
 515
 516 static void decode_flush(AVCodecContext *avctx)
 517 {
 518     IMM4Context *s = avctx->priv_data;
 519
 520     av_frame_unref(s->prev_frame);
 521 }
 522
 523 static av_cold int decode_close(AVCodecContext *avctx)
 524 {
 525     IMM4Context *s = avctx->priv_data;
 526
 527     av_frame_free(&s->prev_frame);
 528     av_freep(&s->bitstream);
 529     s->bitstream_size = 0;
 530
 531     return 0;
 532 }
 533
 534 AVCodec ff_imm4_decoder = {
 535     .name             = "imm4",
 536     .long_name        = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
 537     .type             = AVMEDIA_TYPE_VIDEO,
 538     .id               = AV_CODEC_ID_IMM4,
 539     .priv_data_size   = sizeof(IMM4Context),
 540     .init             = decode_init,
 541     .close            = decode_close,
 542     .decode           = decode_frame,
 543     .flush            = decode_flush,
 544     .capabilities     = AV_CODEC_CAP_DR1,
 545     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
 546                         FF_CODEC_CAP_INIT_CLEANUP,
 547 };