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.
101359 Commits
32 Branches
1.9GB
Tree: ee50f72715
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee50f72715'
${ noResults }
FFmpeg/libavcodec/mv30.c

719 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. #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. 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. };