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