falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
97767 Commits
32 Branches
298MB
Tree: b1cc6b9496
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b1cc6b9496'
${ noResults }
FFmpeg/libavcodec/mv30.c

716 lines
22KB
Raw Blame History 

  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 int t0 = blk[0 * step] + blk[4 * step];

  108.     const int t1 = blk[0 * step] - blk[4 * step];

  109.     const int t2 = blk[2 * step] + blk[6 * step];

  110.     const int t3 = (((blk[2 * step] - blk[6 * step]) * 362) >> 8) - t2;

  111.     const int t4 = t0 + t2;

  112.     const int t5 = t0 - t2;

  113.     const int t6 = t1 + t3;

  114.     const int t7 = t1 - t3;

  115.     const int t8 = blk[5 * step] + blk[3 * step];

  116.     const int t9 = blk[5 * step] - blk[3 * step];

  117.     const int tA = blk[1 * step] + blk[7 * step];

  118.     const int tB = blk[1 * step] - blk[7 * step];

  119.     const int tC = t8 + tA;

  120.     const int tD = (tB + t9) * 473 >> 8;

  121.     const int tE = ((t9 * -669 >> 8) - tC) + tD;

  122.     const int tF = ((tA - t8) * 362 >> 8) - tE;

  123.     const int t10 = ((tB * 277 >> 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 int t0 = blk[0 * step];

  202.     const int t1 = blk[1 * step];

  203.     const int t2 = t1 * 473 >> 8;

  204.     const int t3 = t2 - t1;

  205.     const int t4 = (t1 * 362 >> 8) - t3;

  206.     const int t5 = ((t1 * 277 >> 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] = ((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] = 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] = 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] = (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] = 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] = 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.     skip_bits_long(gb, s->mode_size * 8);

  414. 

  415.     linesize[0] = frame->linesize[0];

  416.     linesize[1] = frame->linesize[0];

  417.     linesize[2] = frame->linesize[0];

  418.     linesize[3] = frame->linesize[0];

  419.     linesize[4] = frame->linesize[1];

  420.     linesize[5] = frame->linesize[2];

  421. 

  422.     for (int y = 0; y < avctx->height; y += 16) {

  423.         GetByteContext gbyte;

  424.         int pfill[3][1] = { {0} };

  425.         int nb_codes = get_bits(gb, 16);

  426. 

  427.         av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));

  428.         if (!s->coeffs)

  429.             return AVERROR(ENOMEM);

  430.         ret = decode_coeffs(gb, s->coeffs, nb_codes);

  431.         if (ret < 0)

  432.             return ret;

  433. 

  434.         bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));

  435. 

  436.         for (int x = 0; x < avctx->width; x += 16) {

  437.             dst[0] = frame->data[0] + linesize[0] * y + x;

  438.             dst[1] = frame->data[0] + linesize[0] * y + x + 8;

  439.             dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;

  440.             dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;

  441.             dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);

  442.             dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);

  443. 

  444.             for (int b = 0; b < 6; b++) {

  445.                 int mode = get_bits_le(&mgb, 2);

  446. 

  447.                 ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],

  448.                                          s->block[b],

  449.                                          pfill[(b >= 4) + (b >= 5)],

  450.                                          dst[b], linesize[b]);

  451.                 if (ret < 0)

  452.                     return ret;

  453.             }

  454.         }

  455.     }

  456. 

  457.     return 0;

  458. }

  459. 

  460. static int decode_inter(AVCodecContext *avctx, GetBitContext *gb,

  461.                         AVFrame *frame, AVFrame *prev)

  462. {

  463.     MV30Context *s = avctx->priv_data;

  464.     GetBitContext mask;

  465.     GetBitContext mgb;

  466.     GetByteContext mv;

  467.     const int mask_size = ((avctx->height >> 4) * (avctx->width >> 4) * 2 + 7) / 8;

  468.     uint8_t *dst[6], *src[6];

  469.     int in_linesize[6];

  470.     int linesize[6];

  471.     int ret, cnt = 0;

  472.     int flags = 0;

  473. 

  474.     in_linesize[0] = prev->linesize[0];

  475.     in_linesize[1] = prev->linesize[0];

  476.     in_linesize[2] = prev->linesize[0];

  477.     in_linesize[3] = prev->linesize[0];

  478.     in_linesize[4] = prev->linesize[1];

  479.     in_linesize[5] = prev->linesize[2];

  480. 

  481.     linesize[0] = frame->linesize[0];

  482.     linesize[1] = frame->linesize[0];

  483.     linesize[2] = frame->linesize[0];

  484.     linesize[3] = frame->linesize[0];

  485.     linesize[4] = frame->linesize[1];

  486.     linesize[5] = frame->linesize[2];

  487. 

  488.     av_fast_padded_malloc(&s->mvectors, &s->mvectors_size, 2 * s->nb_mvectors * sizeof(*s->mvectors));

  489.     if (!s->mvectors) {

  490.         ret = AVERROR(ENOMEM);

  491.         goto fail;

  492.     }

  493. 

  494.     mask = *gb;

  495.     skip_bits_long(gb, mask_size * 8);

  496.     mgb = *gb;

  497.     skip_bits_long(gb, s->mode_size * 8);

  498. 

  499.     ret = decode_coeffs(gb, s->mvectors, 2 * s->nb_mvectors);

  500.     if (ret < 0)

  501.         goto fail;

  502. 

  503.     bytestream2_init(&mv, (uint8_t *)s->mvectors, 2 * s->nb_mvectors * sizeof(*s->mvectors));

  504. 

  505.     for (int y = 0; y < avctx->height; y += 16) {

  506.         GetByteContext gbyte;

  507.         int pfill[3][1] = { {0} };

  508.         int nb_codes = get_bits(gb, 16);

  509. 

  510.         skip_bits(gb, 8);

  511.         if (get_bits_left(gb) < 0) {

  512.             ret = AVERROR_INVALIDDATA;

  513.             goto fail;

  514.         }

  515. 

  516.         av_fast_padded_malloc(&s->coeffs, &s->coeffs_size, nb_codes * sizeof(*s->coeffs));

  517.         if (!s->coeffs) {

  518.             ret = AVERROR(ENOMEM);

  519.             goto fail;

  520.         }

  521. 

  522.         ret = decode_coeffs(gb, s->coeffs, nb_codes);

  523.         if (ret < 0)

  524.             goto fail;

  525. 

  526.         bytestream2_init(&gbyte, (uint8_t *)s->coeffs, nb_codes * sizeof(*s->coeffs));

  527. 

  528.         for (int x = 0; x < avctx->width; x += 16) {

  529.             if (cnt >= 4)

  530.                 cnt = 0;

  531.             if (cnt == 0)

  532.                 flags = get_bits(&mask, 8);

  533. 

  534.             dst[0] = frame->data[0] + linesize[0] * y + x;

  535.             dst[1] = frame->data[0] + linesize[0] * y + x + 8;

  536.             dst[2] = frame->data[0] + linesize[0] * (y + 8) + x;

  537.             dst[3] = frame->data[0] + linesize[0] * (y + 8) + x + 8;

  538.             dst[4] = frame->data[1] + linesize[4] * (y >> 1) + (x >> 1);

  539.             dst[5] = frame->data[2] + linesize[5] * (y >> 1) + (x >> 1);

  540. 

  541.             if ((flags >> (cnt)) & 1) {

  542.                 int mv_x = sign_extend(bytestream2_get_ne16(&mv), 16);

  543.                 int mv_y = sign_extend(bytestream2_get_ne16(&mv), 16);

  544. 

  545.                 int px = x + mv_x;

  546.                 int py = y + mv_y;

  547. 

  548.                 if (px < 0 || px >= avctx->width ||

  549.                     py < 0 || py >= avctx->height)

  550.                     return AVERROR_INVALIDDATA;

  551. 

  552.                 src[0] = prev->data[0] + in_linesize[0] * py + px;

  553.                 src[1] = prev->data[0] + in_linesize[0] * py + px + 8;

  554.                 src[2] = prev->data[0] + in_linesize[0] * (py + 8) + px;

  555.                 src[3] = prev->data[0] + in_linesize[0] * (py + 8) + px + 8;

  556.                 src[4] = prev->data[1] + in_linesize[4] * (py >> 1) + (px >> 1);

  557.                 src[5] = prev->data[2] + in_linesize[5] * (py >> 1) + (px >> 1);

  558. 

  559.                 if ((flags >> (cnt + 4)) & 1) {

  560.                     for (int b = 0; b < 6; b++)

  561.                         copy_block8(dst[b], src[b], linesize[b], in_linesize[b], 8);

  562.                 } else {

  563.                     for (int b = 0; b < 6; b++) {

  564.                         int mode = get_bits_le(&mgb, 2);

  565. 

  566.                         ret = decode_inter_block(avctx, mode, &gbyte, s->interq_tab[b >= 4],

  567.                                                  s->block[b],

  568.                                                  pfill[(b >= 4) + (b >= 5)],

  569.                                                  dst[b], linesize[b],

  570.                                                  src[b], in_linesize[b]);

  571.                         if (ret < 0)

  572.                             goto fail;

  573.                     }

  574.                 }

  575.             } else {

  576.                 for (int b = 0; b < 6; b++) {

  577.                     int mode = get_bits_le(&mgb, 2);

  578. 

  579.                     ret = decode_intra_block(avctx, mode, &gbyte, s->intraq_tab[b >= 4],

  580.                                              s->block[b],

  581.                                              pfill[(b >= 4) + (b >= 5)],

  582.                                              dst[b], linesize[b]);

  583.                     if (ret < 0)

  584.                         goto fail;

  585.                 }

  586.             }

  587. 

  588.             cnt++;

  589.         }

  590.     }

  591. 

  592. fail:

  593.     return ret;

  594. }

  595. 

  596. static int decode_frame(AVCodecContext *avctx, void *data,

  597.                         int *got_frame, AVPacket *avpkt)

  598. {

  599.     MV30Context *s = avctx->priv_data;

  600.     GetBitContext *gb = &s->gb;

  601.     AVFrame *frame = data;

  602.     int ret;

  603. 

  604.     if ((ret = init_get_bits8(gb, avpkt->data, avpkt->size)) < 0)

  605.         return ret;

  606. 

  607.     if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

  608.         return ret;

  609. 

  610.     s->intra_quant = get_bits(gb, 8);

  611.     s->inter_quant = s->intra_quant + get_sbits(gb, 8);

  612.     s->is_inter = get_bits_le(gb, 16);

  613.     s->mode_size = get_bits_le(gb, 16);

  614.     if (s->is_inter)

  615.         s->nb_mvectors = get_bits_le(gb, 16);

  616. 

  617.     get_qtable(s->intraq_tab[0], s->intra_quant, luma_tab);

  618.     get_qtable(s->intraq_tab[1], s->intra_quant, chroma_tab);

  619. 

  620.     frame->key_frame = s->is_inter == 0;

  621. 

  622.     if (frame->key_frame) {

  623.         ret = decode_intra(avctx, gb, frame);

  624.         if (ret < 0)

  625.             return ret;

  626.     } else {

  627.         get_qtable(s->interq_tab[0], s->inter_quant, luma_tab);

  628.         get_qtable(s->interq_tab[1], s->inter_quant, chroma_tab);

  629. 

  630.         if (!s->prev_frame->data[0]) {

  631.             av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");

  632.             return AVERROR_INVALIDDATA;

  633.         }

  634. 

  635.         ret = decode_inter(avctx, gb, frame, s->prev_frame);

  636.         if (ret < 0)

  637.             return ret;

  638.     }

  639. 

  640.     av_frame_unref(s->prev_frame);

  641.     if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)

  642.         return ret;

  643. 

  644.     *got_frame = 1;

  645. 

  646.     return avpkt->size;

  647. }

  648. 

  649. static const uint16_t cbp_codes[] = {

  650.     0, 1, 4, 5, 6, 0xE, 0x1E, 0x3E, 0x7E, 0xFE, 0x1FE, 0x1FF,

  651. };

  652. 

  653. static const uint8_t cbp_bits[] = {

  654.     2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9,

  655. };

  656. 

  657. static av_cold void init_static_data(void)

  658. {

  659.     INIT_VLC_SPARSE_STATIC(&cbp_tab, 9, FF_ARRAY_ELEMS(cbp_bits),

  660.                            cbp_bits, 1, 1, cbp_codes, 2, 2, NULL, 0, 0, 512);

  661. }

  662. 

  663. static av_cold int decode_init(AVCodecContext *avctx)

  664. {

  665.     MV30Context *s = avctx->priv_data;

  666.     static AVOnce init_static_once = AV_ONCE_INIT;

  667. 

  668.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  669.     avctx->color_range = AVCOL_RANGE_JPEG;

  670. 

  671.     ff_blockdsp_init(&s->bdsp, avctx);

  672. 

  673.     s->prev_frame = av_frame_alloc();

  674.     if (!s->prev_frame)

  675.         return AVERROR(ENOMEM);

  676. 

  677.     ff_thread_once(&init_static_once, init_static_data);

  678. 

  679.     return 0;

  680. }

  681. 

  682. static void decode_flush(AVCodecContext *avctx)

  683. {

  684.     MV30Context *s = avctx->priv_data;

  685. 

  686.     av_frame_unref(s->prev_frame);

  687. }

  688. 

  689. static av_cold int decode_close(AVCodecContext *avctx)

  690. {

  691.     MV30Context *s = avctx->priv_data;

  692. 

  693.     av_frame_free(&s->prev_frame);

  694.     av_freep(&s->coeffs);

  695.     s->coeffs_size = 0;

  696.     av_freep(&s->mvectors);

  697.     s->mvectors_size = 0;

  698. 

  699.     return 0;

  700. }

  701. 

  702. AVCodec ff_mv30_decoder = {

  703.     .name             = "mv30",

  704.     .long_name        = NULL_IF_CONFIG_SMALL("MidiVid 3.0"),

  705.     .type             = AVMEDIA_TYPE_VIDEO,

  706.     .id               = AV_CODEC_ID_MV30,

  707.     .priv_data_size   = sizeof(MV30Context),

  708.     .init             = decode_init,

  709.     .close            = decode_close,

  710.     .decode           = decode_frame,

  711.     .flush            = decode_flush,

  712.     .capabilities     = AV_CODEC_CAP_DR1,

  713.     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |

  714.                         FF_CODEC_CAP_INIT_CLEANUP,

  715. };