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.
99601 Commits
32 Branches
283MB
Tree: 77cdc68479
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '77cdc68479'
${ noResults }
FFmpeg/libavcodec/mv30.c

724 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 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. };