git.sesse.net Git - ffmpeg/blob - libavcodec/mv30.c

   1 /*
   2  * MidiVid MV30 decoder
   3  *
   4  * Copyright (c) 2020 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 "bytestream.h"
  31 #include "copy_block.h"
  32 #include "mathops.h"
  33 #include "blockdsp.h"
  34 #include "get_bits.h"
  35 #include "internal.h"
  36
  37 typedef struct MV30Context {
  38     GetBitContext  gb;
  39
  40     int intra_quant;
  41     int inter_quant;
  42     int is_inter;
  43     int mode_size;
  44     int nb_mvectors;
  45
  46     int      block[6][64];
  47     int16_t *mvectors;
  48     unsigned int mvectors_size;
  49     int16_t *coeffs;
  50     unsigned int coeffs_size;
  51
  52     int16_t intraq_tab[2][64];
  53     int16_t interq_tab[2][64];
  54
  55     BlockDSPContext bdsp;
  56     AVFrame *prev_frame;
  57 } MV30Context;
  58
  59 static VLC cbp_tab;
  60
  61 static const int16_t scale_tab[] = {
  62     16384,  22725,  21407,  19266,
  63     16384,  12873,   8867,   4520,
  64     22725,  31521,  29692,  26722,
  65     22725,  17855,  12299,   6270,
  66     21407,  29692,  27969,  25172,
  67     21407,  16819,  11585,   5906,
  68     19266,  26722,  25172,  22654,
  69     19266,  15137,  10426,   5315,
  70     16384,  22725,  21407,  19266,
  71     16384,  12873,   8867,   4520,
  72     12873,  17855,  16819,  15137,
  73     12873,  10114,   6967,   3552,
  74      8867,  12299,  11585,  10426,
  75      8867,   6967,   4799,   2446,
  76      4520,   6270,   5906,   5315,
  77      4520,   3552,   2446,   1247,
  78 };
  79
  80 static const uint8_t luma_tab[] = {
  81     12, 12, 15, 19, 25, 34, 40, 48,
  82     12, 12, 18, 22, 27, 44, 47, 46,
  83     17, 18, 21, 26, 35, 46, 52, 47,
  84     18, 20, 24, 28, 40, 61, 59, 51,
  85     20, 24, 32, 43, 50, 72, 72, 63,
  86     25, 31, 42, 48, 58, 72, 81, 75,
  87     38, 46, 54, 61, 71, 84, 88, 85,
  88     50, 61, 65, 68, 79, 78, 86, 91,
  89 };
  90
  91 static const uint8_t chroma_tab[] = {
  92     12, 16, 24, 47, 99, 99, 99, 99,
  93     16, 21, 26, 66, 99, 99, 99, 99,
  94     24, 26, 56, 99, 99, 99, 99, 99,
  95     47, 66, 99, 99, 99, 99, 99, 99,
  96     99, 99, 99, 99, 99, 99, 99, 99,
  97     99, 99, 99, 99, 99, 99, 99, 99,
  98     99, 99, 99, 99, 99, 99, 99, 99,
  99     99, 99, 99, 99, 99, 99, 99, 99,
 100 };
 101
 102 static const uint8_t zigzag[] = {
 103      0,  1,  8,  9, 16,  2,  3, 10,
 104     17, 24, 32, 25, 18, 11,  4,  5,
 105     12, 19, 26, 33, 40, 48, 41, 34,
 106     27, 20, 13,  6,  7, 14, 21, 28,
 107     35, 42, 49, 56, 57, 50, 43, 36,
 108     29, 22, 15, 23, 30, 37, 44, 51,
 109     58, 59, 52, 45, 38, 31, 39, 46,
 110     53, 60, 61, 54, 47, 55, 62, 63,
 111 };
 112
 113 static void get_qtable(int16_t *table, int quant, const uint8_t *quant_tab)
 114 {
 115     int factor = quant < 50 ? 5000 / FFMAX(quant, 1) : 200 - FFMIN(quant, 100) * 2;
 116
 117     for (int i = 0; i < 64; i++) {
 118         table[i] = av_clip((quant_tab[i] * factor + 0x32) / 100, 1, 0x7fff);
 119         table[i] = ((int)scale_tab[i] * (int)table[i] + 0x800) >> 12;
 120     }
 121 }
 122
 123 static inline void idct_1d(int *blk, int step)
 124 {
 125     const int t0 = blk[0 * step] + blk[4 * step];
 126     const int t1 = blk[0 * step] - blk[4 * step];
 127     const int t2 = blk[2 * step] + blk[6 * step];
 128     const int t3 = (((blk[2 * step] - blk[6 * step]) * 362) >> 8) - t2;
 129     const int t4 = t0 + t2;
 130     const int t5 = t0 - t2;
 131     const int t6 = t1 + t3;
 132     const int t7 = t1 - t3;
 133     const int t8 = blk[5 * step] + blk[3 * step];
 134     const int t9 = blk[5 * step] - blk[3 * step];
 135     const int tA = blk[1 * step] + blk[7 * step];
 136     const int tB = blk[1 * step] - blk[7 * step];
 137     const int tC = t8 + tA;
 138     const int tD = (tB + t9) * 473 >> 8;
 139     const int tE = ((t9 * -669 >> 8) - tC) + tD;
 140     const int tF = ((tA - t8) * 362 >> 8) - tE;
 141     const int t10 = ((tB * 277 >> 8) - tD) + tF;
 142
 143     blk[0 * step] = t4 + tC;
 144     blk[1 * step] = t6 + tE;
 145     blk[2 * step] = t7 + tF;
 146     blk[3 * step] = t5 - t10;
 147     blk[4 * step] = t5 + t10;
 148     blk[5 * step] = t7 - tF;
 149     blk[6 * step] = t6 - tE;
 150     blk[7 * step] = t4 - tC;
 151 }
 152
 153 static void idct_put(uint8_t *dst, int stride, int *block)
 154 {
 155     for (int i = 0; i < 8; i++) {
 156         if ((block[0x08 + i] |
 157              block[0x10 + i] |
 158              block[0x18 + i] |
 159              block[0x20 + i] |
 160              block[0x28 + i] |
 161              block[0x30 + i] |
 162              block[0x38 + i]) == 0) {
 163             block[0x08 + i] = block[i];
 164             block[0x10 + i] = block[i];
 165             block[0x18 + i] = block[i];
 166             block[0x20 + i] = block[i];
 167             block[0x28 + i] = block[i];
 168             block[0x30 + i] = block[i];
 169             block[0x38 + i] = block[i];
 170         } else {
 171             idct_1d(block + i, 8);
 172         }
 173     }
 174
 175     for (int i = 0; i < 8; i++) {
 176         idct_1d(block, 1);
 177         for (int j = 0; j < 8; j++)
 178             dst[j] = av_clip_uint8((block[j] >> 5) + 128);
 179         block += 8;
 180         dst += stride;
 181     }
 182 }
 183
 184 static void idct_add(uint8_t *dst, int stride,
 185                      const uint8_t *src, int in_linesize, int *block)
 186 {
 187     for (int i = 0; i < 8; i++) {
 188         if ((block[0x08 + i] |
 189              block[0x10 + i] |
 190              block[0x18 + i] |
 191              block[0x20 + i] |
 192              block[0x28 + i] |
 193              block[0x30 + i] |
 194              block[0x38 + i]) == 0) {
 195             block[0x08 + i] = block[i];
 196             block[0x10 + i] = block[i];
 197             block[0x18 + i] = block[i];
 198             block[0x20 + i] = block[i];
 199             block[0x28 + i] = block[i];
 200             block[0x30 + i] = block[i];
 201             block[0x38 + i] = block[i];
 202         } else {
 203             idct_1d(block + i, 8);
 204         }
 205     }
 206
 207     for (int i = 0; i < 8; i++) {
 208         idct_1d(block, 1);
 209         for (int j = 0; j < 8; j++)
 210             dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
 211         block += 8;
 212         dst += stride;
 213         src += in_linesize;
 214     }
 215 }
 216
 217 static inline void idct2_1d(int *blk, int step)
 218 {
 219     const int t0 = blk[0 * step];
 220     const int t1 = blk[1 * step];
 221     const int t2 = t1 * 473 >> 8;
 222     const int t3 = t2 - t1;
 223     const int t4 = (t1 * 362 >> 8) - t3;
 224     const int t5 = ((t1 * 277 >> 8) - t2) + t4;
 225
 226     blk[0 * step] = t1 + t0;
 227     blk[1 * step] = t0 + t3;
 228     blk[2 * step] = t4 + t0;
 229     blk[3 * step] = t0 - t5;
 230     blk[4 * step] = t5 + t0;
 231     blk[5 * step] = t0 - t4;
 232     blk[6 * step] = t0 - t3;
 233     blk[7 * step] = t0 - t1;
 234 }
 235
 236 static void idct2_put(uint8_t *dst, int stride, int *block)
 237 {
 238     for (int i = 0; i < 2; i++) {
 239         if ((block[0x08 + i]) == 0) {
 240             block[0x08 + i] = block[i];
 241             block[0x10 + i] = block[i];
 242             block[0x18 + i] = block[i];
 243             block[0x20 + i] = block[i];
 244             block[0x28 + i] = block[i];
 245             block[0x30 + i] = block[i];
 246             block[0x38 + i] = block[i];
 247         } else {
 248             idct2_1d(block + i, 8);
 249         }
 250     }
 251
 252     for (int i = 0; i < 8; i++) {
 253         if (block[1] == 0) {
 254             for (int j = 0; j < 8; j++)
 255                 dst[j] = av_clip_uint8((block[0] >> 5) + 128);
 256         } else {
 257             idct2_1d(block, 1);
 258             for (int j = 0; j < 8; j++)
 259                 dst[j] = av_clip_uint8((block[j] >> 5) + 128);
 260         }
 261         block += 8;
 262         dst += stride;
 263     }
 264 }
 265
 266 static void idct2_add(uint8_t *dst, int stride,
 267                       const uint8_t *src, int in_linesize,
 268                       int *block)
 269 {
 270     for (int i = 0; i < 2; i++) {
 271         if ((block[0x08 + i]) == 0) {
 272             block[0x08 + i] = block[i];
 273             block[0x10 + i] = block[i];
 274             block[0x18 + i] = block[i];
 275             block[0x20 + i] = block[i];
 276             block[0x28 + i] = block[i];
 277             block[0x30 + i] = block[i];
 278             block[0x38 + i] = block[i];
 279         } else {
 280             idct2_1d(block + i, 8);
 281         }
 282     }
 283
 284     for (int i = 0; i < 8; i++) {
 285         if (block[1] == 0) {
 286             for (int j = 0; j < 8; j++)
 287                 dst[j] = av_clip_uint8((block[0] >> 5) + src[j]);
 288         } else {
 289             idct2_1d(block, 1);
 290             for (int j = 0; j < 8; j++)
 291                 dst[j] = av_clip_uint8((block[j] >> 5) + src[j]);
 292         }
 293         block += 8;
 294         dst += stride;
 295         src += in_linesize;
 296     }
 297 }
 298
 299 static void update_inter_block(uint8_t *dst, int stride,
 300                                const uint8_t *src, int in_linesize,
 301                                int block)
 302 {
 303     for (int i = 0; i < 8; i++) {
 304         for (int j = 0; j < 8; j++)
 305             dst[j] = av_clip_uint8(block + src[j]);
 306         dst += stride;
 307         src += in_linesize;
 308     }
 309 }
 310
 311 static int decode_intra_block(AVCodecContext *avctx, int mode,
 312                               GetByteContext *gbyte, int16_t *qtab,
 313                               int *block, int *pfill,
 314                               uint8_t *dst, int linesize)
 315 {
 316     MV30Context *s = avctx->priv_data;
 317     int fill;
 318
 319     switch (mode) {
 320     case 0:
 321         s->bdsp.fill_block_tab[1](dst, 128, linesize, 8);
 322         break;
 323     case 1:
 324         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 325         pfill[0] += fill;
 326         block[0] = ((pfill[0] * qtab[0]) >> 5) + 128;
 327         s->bdsp.fill_block_tab[1](dst, block[0], linesize, 8);
 328         break;
 329     case 2:
 330         memset(block, 0, sizeof(*block) * 64);
 331         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 332         pfill[0] += fill;
 333         block[0] = pfill[0] * qtab[0];
 334         block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
 335         block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
 336         block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
 337         idct2_put(dst, linesize, block);
 338         break;
 339     case 3:
 340         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 341         pfill[0] += fill;
 342         block[0] = pfill[0] * qtab[0];
 343         for (int i = 1; i < 64; i++)
 344             block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
 345         idct_put(dst, linesize, block);
 346         break;
 347     }
 348
 349     return 0;
 350 }
 351
 352 static int decode_inter_block(AVCodecContext *avctx, int mode,
 353                               GetByteContext *gbyte, int16_t *qtab,
 354                               int *block, int *pfill,
 355                               uint8_t *dst, int linesize,
 356                               const uint8_t *src, int in_linesize)
 357 {
 358     int fill;
 359
 360     switch (mode) {
 361     case 0:
 362         copy_block8(dst, src, linesize, in_linesize, 8);
 363         break;
 364     case 1:
 365         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 366         pfill[0] += fill;
 367         block[0] = (pfill[0] * qtab[0]) >> 5;
 368         update_inter_block(dst, linesize, src, in_linesize, block[0]);
 369         break;
 370     case 2:
 371         memset(block, 0, sizeof(*block) * 64);
 372         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 373         pfill[0] += fill;
 374         block[0] = pfill[0] * qtab[0];
 375         block[1] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[1];
 376         block[8] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[8];
 377         block[9] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[9];
 378         idct2_add(dst, linesize, src, in_linesize, block);
 379         break;
 380     case 3:
 381         fill = sign_extend(bytestream2_get_ne16(gbyte), 16);
 382         pfill[0] += fill;
 383         block[0] = pfill[0] * qtab[0];
 384         for (int i = 1; i < 64; i++)
 385             block[zigzag[i]] = sign_extend(bytestream2_get_ne16(gbyte), 16) * qtab[zigzag[i]];
 386         idct_add(dst, linesize, src, in_linesize, block);
 387         break;
 388     }
 389
 390     return 0;
 391 }
 392
 393 static int decode_coeffs(GetBitContext *gb, int16_t *coeffs, int nb_codes)
 394 {
 395     memset(coeffs, 0, nb_codes * sizeof(*coeffs));
 396
 397     for (int i = 0; i < nb_codes;) {
 398         int value = get_vlc2(gb, cbp_tab.table, cbp_tab.bits, 1);
 399
 400         if (value < 0)
 401             return AVERROR_INVALIDDATA;
 402
 403         if (value > 0) {
 404             int x = get_bits(gb, value);
 405
 406             if (x < (1 << value) / 2) {
 407                 x =  (1 << (value - 1)) + (x & ((1 << value) - 1 >> 1));
 408             } else {
 409                 x = -(1 << (value - 1)) - (x & ((1 << value) - 1 >> 1));
 410             }
 411             coeffs[i++] = x;
 412         } else {
 413             int flag = get_bits1(gb);
 414
 415             i += get_bits(gb, 3 + flag * 3) + 1 + flag * 8;
 416         }
 417     }
 418
 419     return 0;
 420 }
 421
 422 static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
 423 {
 424     MV30Context *s = avctx->priv_data;
 425     GetBitContext mgb;
 426     uint8_t *dst[6];
 427     int linesize[6];
 428     int ret;
 429
 430     mgb = *gb;
 431     skip_bits_long(gb, s->mode_size * 8);
 432
 433     linesize[0] = frame->linesize[0];
 434     linesize[1] = frame->linesize[0];
 435     linesize[2] = frame->linesize[0];
 436     linesize[3] = frame->linesize[0];
 437     linesize[4] = frame->linesize[1];
 438     linesize[5] = frame->linesize[2];
 439
 440     for (int y = 0; y < avctx->height; y += 16) {
 441         GetByteContext gbyte;
 442         int pfill[3][1] = { 0 };
 443         int nb_codes = get_bits(gb, 16);
 444
 445         av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
 446         if (!s->coeffs)
 447             return AVERROR(ENOMEM);
 448         ret = decode_coeffs(gb, s->coeffs, nb_codes);
 449         if (ret < 0)
 450             return ret;
 451
 452         bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
 453
 454         for (int x = 0; x < avctx->width; x += 16) {
 455             dst[0] = frame->data[0] + linesize[0] * y + x;
 456             dst[1] = frame->data[0] + linesize[0] * y + x + 8;
 457             dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
 458             dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
 459             dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
 460             dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
 461
 462             for (int b = 0; b < 6; b++) {
 463                 int mode = get_bits_le(&mgb, 2);
 464
 465                 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
 466                                          s->block[b],
 467                                          pfill[(b >= 4) + (b >= 5)],
 468                                          dst[b], linesize[b]);
 469                 if (ret < 0)
 470                     return ret;
 471             }
 472         }
 473     }
 474
 475     return 0;
 476 }
 477
 478 static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,
 479                         AVFrame *frame, AVFrame *prev)
 480 {
 481     MV30Context *s = avctx->priv_data;
 482     GetBitContext mask;
 483     GetBitContext mgb;
 484     GetByteContext mv;
 485     const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;
 486     uint8_t *dst[6], *src[6];
 487     int in_linesize[6];
 488     int linesize[6];
 489     int ret, cnt = 0;
 490     int flags = 0;
 491
 492     in_linesize[0] = prev->linesize[0];
 493     in_linesize[1] = prev->linesize[0];
 494     in_linesize[2] = prev->linesize[0];
 495     in_linesize[3] = prev->linesize[0];
 496     in_linesize[4] = prev->linesize[1];
 497     in_linesize[5] = prev->linesize[2];
 498
 499     linesize[0] = frame->linesize[0];
 500     linesize[1] = frame->linesize[0];
 501     linesize[2] = frame->linesize[0];
 502     linesize[3] = frame->linesize[0];
 503     linesize[4] = frame->linesize[1];
 504     linesize[5] = frame->linesize[2];
 505
 506     av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));
 507     if (!s->mvectors) {
 508         ret = AVERROR(ENOMEM);
 509         goto fail;
 510     }
 511
 512     mask = *gb;
 513     skip_bits_long(gb, mask_size * 8);
 514     mgb = *gb;
 515     skip_bits_long(gb, s->mode_size * 8);
 516
 517     ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);
 518     if (ret < 0)
 519         goto fail;
 520
 521     bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));
 522
 523     for (int y = 0; y < avctx->height; y += 16) {
 524         GetByteContext gbyte;
 525         int pfill[3][1] = { 0 };
 526         int nb_codes = get_bits(gb, 16);
 527
 528         skip_bits(gb, 8);
 529         if (get_bits_left(gb) < 0) {
 530             ret = AVERROR_INVALIDDATA;
 531             goto fail;
 532         }
 533
 534         av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));
 535         if (!s->coeffs) {
 536             ret = AVERROR(ENOMEM);
 537             goto fail;
 538         }
 539
 540         ret = decode_coeffs(gb, s->coeffs, nb_codes);
 541         if (ret < 0)
 542             goto fail;
 543
 544         bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));
 545
 546         for (int x = 0; x < avctx->width; x += 16) {
 547             if (cnt >= 4)
 548                 cnt = 0;
 549             if (cnt == 0)
 550                 flags = get_bits(&mask, 8);
 551
 552             dst[0] = frame->data[0] + linesize[0] * y + x;
 553             dst[1] = frame->data[0] + linesize[0] * y + x + 8;
 554             dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;
 555             dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;
 556             dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);
 557             dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);
 558
 559             if ((flags >> (cnt)) & 1) {
 560                 int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);
 561                 int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);
 562
 563                 int px = x + mv_x;
 564                 int py = y + mv_y;
 565
 566                 if (px < 0 || px >= avctx->width ||
 567                     py < 0 || py >= avctx->height)
 568                     return AVERROR_INVALIDDATA;
 569
 570                 src[0] = prev->data[0] + in_linesize[0] * py + px;
 571                 src[1] = prev->data[0] + in_linesize[0] * py + px + 8;
 572                 src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;
 573                 src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;
 574                 src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);
 575                 src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);
 576
 577                 if ((flags >> (cnt + 4)) & 1) {
 578                     for (int b = 0; b < 6; b++)
 579                         copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);
 580                 } else {
 581                     for (int b = 0; b < 6; b++) {
 582                         int mode = get_bits_le(&mgb, 2);
 583
 584                         ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],
 585                                                  s->block[b],
 586                                                  pfill[(b >= 4) + (b >= 5)],
 587                                                  dst[b], linesize[b],
 588                                                  src[b], in_linesize[b]);
 589                         if (ret < 0)
 590                             goto fail;
 591                     }
 592                 }
 593             } else {
 594                 for (int b = 0; b < 6; b++) {
 595                     int mode = get_bits_le(&mgb, 2);
 596
 597                     ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],
 598                                              s->block[b],
 599                                              pfill[(b >= 4) + (b >= 5)],
 600                                              dst[b], linesize[b]);
 601                     if (ret < 0)
 602                         goto fail;
 603                 }
 604             }
 605
 606             cnt++;
 607         }
 608     }
 609
 610 fail:
 611     return ret;
 612 }
 613
 614 static int decode_frame(AVCodecContext *avctx, void *data,
 615                         int *got_frame, AVPacket *avpkt)
 616 {
 617     MV30Context *s = avctx->priv_data;
 618     GetBitContext *gb = &s->gb;
 619     AVFrame *frame = data;
 620     int ret;
 621
 622     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)
 623         return ret;
 624
 625     if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
 626         return ret;
 627
 628     s->intra_quant = get_bits(gb, 8);
 629     s->inter_quant = s->intra_quant + get_sbits(gb, 8);
 630     s->is_inter = get_bits_le(gb, 16);
 631     s->mode_size = get_bits_le(gb, 16);
 632     if (s->is_inter)
 633         s->nb_mvectors = get_bits_le(gb, 16);
 634
 635     get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);
 636     get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);
 637
 638     frame->key_frame = s->is_inter == 0;
 639
 640     if (frame->key_frame) {
 641         ret = decode_intra(avctx, gb, frame);
 642         if (ret < 0)
 643             return ret;
 644     } else {
 645         get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);
 646         get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);
 647
 648         if (!s->prev_frame->data[0]) {
 649             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
 650             return AVERROR_INVALIDDATA;
 651         }
 652
 653         ret = decode_inter(avctx, gb, frame, s->prev_frame);
 654         if (ret < 0)
 655             return ret;
 656     }
 657
 658     av_frame_unref(s->prev_frame);
 659     if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
 660         return ret;
 661
 662     *got_frame = 1;
 663
 664     return avpkt->size;
 665 }
 666
 667 static const uint16_t cbp_codes[] = {
 668     0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF,
 669 };
 670
 671 static const uint8_t cbp_bits[] = {
 672     2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,
 673 };
 674
 675 static av_cold void init_static_data(void)
 676 {
 677     INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits),
 678                            cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512);
 679 }
 680
 681 static av_cold int decode_init(AVCodecContext *avctx)
 682 {
 683     MV30Context *s = avctx->priv_data;
 684     static AVOnce init_static_once = AV_ONCE_INIT;
 685
 686     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 687     avctx->color_range = AVCOL_RANGE_JPEG;
 688
 689     ff_blockdsp_init(&s->bdsp, avctx);
 690
 691     s->prev_frame = av_frame_alloc();
 692     if (!s->prev_frame)
 693         return AVERROR(ENOMEM);
 694
 695     ff_thread_once(&init_static_once, init_static_data);
 696
 697     return 0;
 698 }
 699
 700 static void decode_flush(AVCodecContext *avctx)
 701 {
 702     MV30Context *s = avctx->priv_data;
 703
 704     av_frame_unref(s->prev_frame);
 705 }
 706
 707 static av_cold int decode_close(AVCodecContext *avctx)
 708 {
 709     MV30Context *s = avctx->priv_data;
 710
 711     av_frame_free(&s->prev_frame);
 712     av_freep(&s->coeffs);
 713     s->coeffs_size = 0;
 714     av_freep(&s->mvectors);
 715     s->mvectors_size = 0;
 716
 717     return 0;
 718 }
 719
 720 AVCodec ff_mv30_decoder = {
 721     .name             = "mv30",
 722     .long_name        = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),
 723     .type             = AVMEDIA_TYPE_VIDEO,
 724     .id               = AV_CODEC_ID_MV30,
 725     .priv_data_size   = sizeof(MV30Context),
 726     .init             = decode_init,
 727     .close            = decode_close,
 728     .decode           = decode_frame,
 729     .flush            = decode_flush,
 730     .capabilities     = AV_CODEC_CAP_DR1,
 731     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
 732                         FF_CODEC_CAP_INIT_CLEANUP,
 733 };