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