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.
99142 Commits
32 Branches
293MB
Tree: bd7d832e84
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bd7d832e84'
${ noResults }
FFmpeg/libavcodec/mobiclip.c

1440 lines
44KB
Raw Blame History 

  1. /*

  2.  * MobiClip Video decoder

  3.  * Copyright (c) 2017 Adib Surani

  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 <inttypes.h>

  24. 

  25. #include "libavutil/avassert.h"

  26. 

  27. #include "avcodec.h"

  28. #include "bytestream.h"

  29. #include "bswapdsp.h"

  30. #include "get_bits.h"

  31. #include "golomb.h"

  32. #include "internal.h"

  33. 

  34. static const uint8_t zigzag4x4_tab[] =

  35. {

  36.     0x00, 0x04, 0x01, 0x02, 0x05, 0x08, 0x0C, 0x09, 0x06, 0x03, 0x07, 0x0A,

  37.     0x0D, 0x0E, 0x0B, 0x0F

  38. };

  39. 

  40. static const uint8_t quant4x4_tab[][16] =

  41. {

  42.     { 10, 13, 13, 10, 16, 10, 13, 13, 13, 13, 16, 10, 16, 13, 13, 16 },

  43.     { 11, 14, 14, 11, 18, 11, 14, 14, 14, 14, 18, 11, 18, 14, 14, 18 },

  44.     { 13, 16, 16, 13, 20, 13, 16, 16, 16, 16, 20, 13, 20, 16, 16, 20 },

  45.     { 14, 18, 18, 14, 23, 14, 18, 18, 18, 18, 23, 14, 23, 18, 18, 23 },

  46.     { 16, 20, 20, 16, 25, 16, 20, 20, 20, 20, 25, 16, 25, 20, 20, 25 },

  47.     { 18, 23, 23, 18, 29, 18, 23, 23, 23, 23, 29, 18, 29, 23, 23, 29 },

  48. };

  49. 

  50. static const uint8_t quant8x8_tab[][64] =

  51. {

  52.     { 20, 19, 19, 25, 18, 25, 19, 24, 24, 19, 20, 18, 32, 18, 20, 19, 19, 24, 24, 19, 19, 25, 18, 25, 18, 25, 18, 25, 19, 24, 24, 19,

  53.       19, 24, 24, 19, 18, 32, 18, 20, 18, 32, 18, 24, 24, 19, 19, 24, 24, 18, 25, 18, 25, 18, 19, 24, 24, 19, 18, 32, 18, 24, 24, 18,},

  54.     { 22, 21, 21, 28, 19, 28, 21, 26, 26, 21, 22, 19, 35, 19, 22, 21, 21, 26, 26, 21, 21, 28, 19, 28, 19, 28, 19, 28, 21, 26, 26, 21,

  55.       21, 26, 26, 21, 19, 35, 19, 22, 19, 35, 19, 26, 26, 21, 21, 26, 26, 19, 28, 19, 28, 19, 21, 26, 26, 21, 19, 35, 19, 26, 26, 19,},

  56.     { 26, 24, 24, 33, 23, 33, 24, 31, 31, 24, 26, 23, 42, 23, 26, 24, 24, 31, 31, 24, 24, 33, 23, 33, 23, 33, 23, 33, 24, 31, 31, 24,

  57.       24, 31, 31, 24, 23, 42, 23, 26, 23, 42, 23, 31, 31, 24, 24, 31, 31, 23, 33, 23, 33, 23, 24, 31, 31, 24, 23, 42, 23, 31, 31, 23,},

  58.     { 28, 26, 26, 35, 25, 35, 26, 33, 33, 26, 28, 25, 45, 25, 28, 26, 26, 33, 33, 26, 26, 35, 25, 35, 25, 35, 25, 35, 26, 33, 33, 26,

  59.       26, 33, 33, 26, 25, 45, 25, 28, 25, 45, 25, 33, 33, 26, 26, 33, 33, 25, 35, 25, 35, 25, 26, 33, 33, 26, 25, 45, 25, 33, 33, 25,},

  60.     { 32, 30, 30, 40, 28, 40, 30, 38, 38, 30, 32, 28, 51, 28, 32, 30, 30, 38, 38, 30, 30, 40, 28, 40, 28, 40, 28, 40, 30, 38, 38, 30,

  61.       30, 38, 38, 30, 28, 51, 28, 32, 28, 51, 28, 38, 38, 30, 30, 38, 38, 28, 40, 28, 40, 28, 30, 38, 38, 30, 28, 51, 28, 38, 38, 28,},

  62.     { 36, 34, 34, 46, 32, 46, 34, 43, 43, 34, 36, 32, 58, 32, 36, 34, 34, 43, 43, 34, 34, 46, 32, 46, 32, 46, 32, 46, 34, 43, 43, 34,

  63.       34, 43, 43, 34, 32, 58, 32, 36, 32, 58, 32, 43, 43, 34, 34, 43, 43, 32, 46, 32, 46, 32, 34, 43, 43, 34, 32, 58, 32, 43, 43, 32,},

  64. };

  65. 

  66. static const uint8_t block4x4_coefficients_tab[] =

  67. {

  68.     15, 0, 2, 1, 4, 8, 12, 3, 11, 13, 14, 7, 10, 5, 9, 6,

  69. };

  70. 

  71. static const uint8_t pframe_block4x4_coefficients_tab[] =

  72. {

  73.     0, 4, 1, 8, 2, 12, 3, 5, 10, 15, 7, 13, 14, 11, 9, 6,

  74. };

  75. 

  76. static const uint8_t block8x8_coefficients_tab[] =

  77. {

  78.     0x00, 0x1F, 0x3F, 0x0F, 0x08, 0x04, 0x02, 0x01, 0x0B, 0x0E, 0x1B, 0x0D,

  79.     0x03, 0x07, 0x0C, 0x17, 0x1D, 0x0A, 0x1E, 0x05, 0x10, 0x2F, 0x37, 0x3B,

  80.     0x13, 0x3D, 0x3E, 0x09, 0x1C, 0x06, 0x15, 0x1A, 0x33, 0x11, 0x12, 0x14,

  81.     0x18, 0x20, 0x3C, 0x35, 0x19, 0x16, 0x3A, 0x30, 0x31, 0x32, 0x27, 0x34,

  82.     0x2B, 0x2D, 0x39, 0x38, 0x23, 0x36, 0x2E, 0x21, 0x25, 0x22, 0x24, 0x2C,

  83.     0x2A, 0x28, 0x29, 0x26,

  84. };

  85. 

  86. static const uint8_t pframe_block8x8_coefficients_tab[] =

  87. {

  88.     0x00, 0x0F, 0x04, 0x01, 0x08, 0x02, 0x0C, 0x03, 0x05, 0x0A, 0x0D, 0x07, 0x0E, 0x0B, 0x1F, 0x09,

  89.     0x06, 0x10, 0x3F, 0x1E, 0x17, 0x1D, 0x1B, 0x1C, 0x13, 0x18, 0x1A, 0x12, 0x11, 0x14, 0x15, 0x20,

  90.     0x2F, 0x16, 0x19, 0x37, 0x3D, 0x3E, 0x3B, 0x3C, 0x33, 0x35, 0x21, 0x24, 0x22, 0x28, 0x23, 0x2C,

  91.     0x30, 0x27, 0x2D, 0x25, 0x3A, 0x2B, 0x2E, 0x2A, 0x31, 0x34, 0x38, 0x32, 0x29, 0x26, 0x39, 0x36

  92. };

  93. 

  94. static const uint8_t run_residue[2][256] =

  95. {

  96.     {

  97.        12,  6,  4,  3,  3,  3,  3,  2,  2,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,

  98.         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  99.         3,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  100.         1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  101.         1, 27, 11,  7,  3,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  102.         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  103.         1, 41,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  104.         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  105.     },

  106.     {

  107.        27, 10,  5,  4,  3,  3,  3,  3,  2,  2,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  108.         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  109.         8,  3,  2,  2,  2,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  110.         0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  111.         1, 15, 10,  8,  4,  3,  2,  2,  2,  2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  112.         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  113.         1, 21,  7,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  114.         1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,

  115.     },

  116. };

  117. 

  118. static const uint8_t bits0[] = {

  119.      9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,

  120.     10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12,

  121.     12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,  7, 10, 10,  9,

  122.      9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,

  123.      9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,

  124.      8,  8,  8,  7,  7,  7,  7,  7,  7,  7,  7,  6,  6,  6,  6,

  125.      6,  6,  6,  6,  6,  6,  5,  5,  5,  4,  2,  3,  4,  4,

  126. };

  127. 

  128. static const uint16_t codes0[] = {

  129.     0x0, 0x4, 0x5, 0x6, 0x7, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA,

  130.     0xB, 0xC, 0xD, 0xE, 0xF, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,

  131.     0x26, 0x27, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,

  132.     0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x3, 0x20,

  133.     0x21, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,

  134.     0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23,

  135.     0x24, 0x25, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A,

  136.     0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x10, 0x11, 0x12, 0x13, 0x14,

  137.     0x15, 0x16, 0x17, 0xC, 0xD, 0xE, 0xF, 0x10, 0x11, 0x12,

  138.     0x13, 0x14, 0x15, 0xB, 0xC, 0xD, 0x7, 0x2, 0x6, 0xE, 0xF,

  139. };

  140. 

  141. static const uint16_t syms0[] = {

  142.     0x0, 0x822, 0x803, 0xB, 0xA, 0xB81, 0xB61, 0xB41, 0xB21, 0x122,

  143.     0x102, 0xE2, 0xC2, 0xA2, 0x63, 0x43, 0x24, 0xC, 0x25, 0x2E1, 0x301,

  144.     0xBA1, 0xBC1, 0xBE1, 0xC01, 0x26, 0x44, 0x83, 0xA3, 0xC3, 0x142,

  145.     0x321, 0x341, 0xC21, 0xC41, 0xC61, 0xC81, 0xCA1, 0xCC1, 0xCE1, 0xD01,

  146.     0x0, 0x9, 0x8, 0xB01, 0xAE1, 0xAC1, 0xAA1, 0xA81, 0xA61, 0xA41, 0xA21,

  147.     0x802, 0x2C1, 0x2A1, 0x281, 0x261, 0x241, 0x221, 0x201, 0x1E1, 0x82,

  148.     0x62, 0x7, 0x6, 0xA01, 0x9E1, 0x9C1, 0x9A1, 0x981, 0x961, 0x941, 0x921,

  149.     0x1C1, 0x1A1, 0x42, 0x23, 0x5, 0x901, 0x8E1, 0x8C1, 0x8A1, 0x181, 0x161,

  150.     0x141, 0x4, 0x881, 0x861, 0x841, 0x821, 0x121, 0x101, 0xE1, 0xC1, 0x22,

  151.     0x3, 0xA1, 0x81, 0x61, 0x801, 0x1, 0x21, 0x41, 0x2,

  152. };

  153. 

  154. static const uint16_t syms1[] = {

  155.     0x0, 0x807, 0x806, 0x16, 0x15, 0x842, 0x823, 0x805, 0x1A1, 0xA3, 0x102, 0x83,

  156.     0x64, 0x44, 0x27, 0x14, 0x13, 0x17, 0x18, 0x28, 0x122, 0x862, 0x882, 0x9E1, 0xA01,

  157.     0x19, 0x1A, 0x1B, 0x29, 0xC3, 0x2A, 0x45, 0xE3, 0x1C1, 0x808, 0x8A2, 0x8C2, 0xA21,

  158.     0xA41, 0xA61, 0xA81, 0x0, 0x12, 0x11, 0x9C1, 0x9A1, 0x981, 0x961, 0x941, 0x822, 0x804,

  159.     0x181, 0x161, 0xE2, 0xC2, 0xA2, 0x63, 0x43, 0x26, 0x25, 0x10, 0x82, 0xF, 0xE, 0xD, 0x901,

  160.     0x8E1, 0x8C1, 0x803, 0x141, 0x121, 0x101, 0x921, 0x62, 0x24, 0xC, 0xB, 0xA, 0x881, 0x861,

  161.     0xC1, 0x8A1, 0xE1, 0x42, 0x23, 0x9, 0x802, 0xA1, 0x841, 0x821, 0x81, 0x61, 0x8, 0x7, 0x22,

  162.     0x6, 0x41, 0x5, 0x4, 0x801, 0x1, 0x2, 0x21, 0x3,

  163. };

  164. 

  165. static const uint8_t mv_len[16] =

  166. {

  167.     10, 8, 8, 7, 8, 8, 8, 7, 8, 8, 8, 7, 7, 7, 7, 6,

  168. };

  169. 

  170. static const uint8_t mv_bits[16][10] =

  171. {

  172.     { 1, 3, 3, 4, 4, 5, 5, 5, 6, 6 },

  173.     { 2, 2, 3, 3, 3, 4, 5, 5 },

  174.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  175.     { 1, 3, 3, 4, 4, 4, 4 },

  176.     { 2, 2, 3, 3, 3, 4, 5, 5 },

  177.     { 2, 3, 3, 3, 3, 3, 4, 4 },

  178.     { 1, 3, 3, 4, 4, 4, 5, 5 },

  179.     { 1, 3, 3, 4, 4, 4, 4 },

  180.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  181.     { 1, 3, 3, 4, 4, 4, 5, 5 },

  182.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  183.     { 2, 2, 3, 3, 3, 4, 4 },

  184.     { 1, 3, 3, 4, 4, 4, 4 },

  185.     { 1, 3, 3, 4, 4, 4, 4 },

  186.     { 2, 2, 3, 3, 3, 4, 4 },

  187.     { 2, 2, 3, 3, 3, 3 },

  188. };

  189. 

  190. static const uint8_t mv_codes[16][10] =

  191. {

  192.     { 1, 0, 2, 2, 7, 6, 7, 12, 26, 27 },

  193.     { 0, 2, 2, 6, 7, 6, 14, 15 },

  194.     { 0, 3, 3, 4, 4, 5, 10, 11 },

  195.     { 0, 5, 7, 8, 9, 12, 13 },

  196.     { 1, 3, 0, 1, 5, 8, 18, 19 },

  197.     { 3, 0, 2, 3, 4, 5, 2, 3 },

  198.     { 0, 4, 5, 12, 13, 14, 30, 31 },

  199.     { 0, 5, 6, 8, 9, 14, 15 },

  200.     { 0, 3, 3, 4, 4, 5, 10, 11 },

  201.     { 0, 4, 5, 12, 13, 14, 30, 31 },

  202.     { 0, 3, 2, 5, 6, 7, 8, 9 },

  203.     { 0, 3, 2, 3, 5, 8, 9 },

  204.     { 0, 5, 6, 8, 9, 14, 15 },

  205.     { 0, 5, 6, 8, 9, 14, 15 },

  206.     { 0, 3, 2, 3, 5, 8, 9 },

  207.     { 0, 3, 2, 3, 4, 5 },

  208. };

  209. 

  210. static const uint8_t mv_syms[16][10] =

  211. {

  212.     { 0, 8, 1, 2, 9, 3, 6, 7, 5, 4 },

  213.     { 9, 1, 2, 8, 0, 3, 5, 4 },

  214.     { 0, 1, 2, 9, 5, 4, 3, 8 },

  215.     { 1, 2, 0, 5, 4, 8, 3 },

  216.     { 8, 1, 2, 9, 0, 3, 5, 4 },

  217.     { 1, 3, 2, 9, 8, 0, 5, 4 },

  218.     { 1, 2, 0, 9, 8, 3, 5, 4 },

  219.     { 1, 2, 0, 8, 5, 4, 3 },

  220.     { 0, 1, 2, 8, 5, 4, 3, 9 },

  221.     { 1, 2, 0, 9, 8, 3, 5, 4 },

  222.     { 0, 1, 3, 2, 9, 8, 5, 4 },

  223.     { 0, 1, 4, 3, 2, 8, 5 },

  224.     { 1, 2, 0, 5, 4, 9, 3 },

  225.     { 1, 2, 0, 9, 5, 4, 3 },

  226.     { 0, 1, 5, 3, 2, 9, 4 },

  227.     { 0, 1, 4, 5, 3, 2 },

  228. };

  229. 

  230. static const uint8_t mv_bits_mods[16][10] =

  231. {

  232.     { 2, 2, 3, 3, 4, 4, 5, 5, 5, 5 },

  233.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  234.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  235.     { 1, 3, 3, 3, 4, 5, 5 },

  236.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  237.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  238.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  239.     { 2, 2, 2, 3, 4, 5, 5 },

  240.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  241.     { 2, 2, 3, 3, 4, 4, 4, 4 },

  242.     { 2, 2, 3, 3, 3, 4, 5, 5 },

  243.     { 2, 2, 3, 3, 3, 4, 4 },

  244.     { 1, 3, 3, 4, 4, 4, 4 },

  245.     { 2, 2, 3, 3, 3, 4, 4 },

  246.     { 2, 2, 3, 3, 3, 4, 4 },

  247.     { 2, 2, 3, 3, 3, 3 },

  248. };

  249. 

  250. static const uint8_t mv_codes_mods[16][10] =

  251. {

  252.     { 0, 3, 2, 3, 9, 10, 16, 17, 22, 23 },

  253.     { 0, 3, 2, 4, 6, 7, 10, 11 },

  254.     { 1, 3, 0, 5, 2, 3, 8, 9 },

  255.     { 0, 4, 6, 7, 10, 22, 23 },

  256.     { 0, 3, 3, 4, 4, 5, 10, 11 },

  257.     { 0, 3, 2, 5, 6, 7, 8, 9 },

  258.     { 0, 3, 2, 5, 6, 7, 8, 9 },

  259.     { 0, 1, 3, 4, 10, 22, 23 },

  260.     { 0, 3, 2, 4, 6, 7, 10, 11 },

  261.     { 0, 3, 3, 5, 4, 5, 8, 9 },

  262.     { 0, 3, 2, 3, 5, 9, 16, 17 },

  263.     { 0, 3, 2, 4, 5, 6, 7 },

  264.     { 0, 5, 6, 8, 9, 14, 15 },

  265.     { 0, 3, 2, 4, 5, 6, 7 },

  266.     { 0, 3, 2, 4, 5, 6, 7 },

  267.     { 1, 2, 0, 1, 6, 7 },

  268. };

  269. 

  270. static const uint8_t mv_syms_mods[16][10] =

  271. {

  272.     { 1, 0, 8, 9, 2, 7, 4, 3, 5, 6 },

  273.     { 0, 1, 9, 2, 5, 4, 3, 8 },

  274.     { 0, 1, 3, 2, 9, 5, 4, 8 },

  275.     { 1, 3, 2, 0, 4, 8, 5 },

  276.     { 0, 1, 8, 2, 5, 4, 3, 9 },

  277.     { 0, 1, 3, 2, 5, 9, 4, 8 },

  278.     { 0, 1, 3, 2, 9, 5, 8, 4 },

  279.     { 0, 2, 1, 3, 4, 8, 5 },

  280.     { 0, 1, 3, 2, 8, 4, 5, 9 },

  281.     { 2, 1, 3, 0, 8, 9, 5, 4 },

  282.     { 0, 1, 4, 3, 2, 5, 8, 9 },

  283.     { 0, 1, 4, 3, 2, 8, 5 },

  284.     { 1, 2, 0, 9, 4, 5, 3 },

  285.     { 2, 1, 4, 3, 0, 9, 5 },

  286.     { 0, 1, 4, 3, 2, 9, 5 },

  287.     { 1, 0, 5, 4, 3, 2 },

  288. };

  289. 

  290. typedef struct BlockXY {

  291.     int w, h;

  292.     int ax, ay;

  293.     int x, y;

  294.     int size;

  295.     uint8_t *block;

  296.     int linesize;

  297. } BlockXY;

  298. 

  299. typedef struct MotionXY {

  300.     int x, y;

  301. } MotionXY;

  302. 

  303. typedef struct MobiClipContext {

  304.     AVFrame *pic[6];

  305. 

  306.     int current_pic;

  307.     int moflex;

  308.     int dct_tab_idx;

  309.     int quantizer;

  310. 

  311.     GetBitContext gb;

  312. 

  313.     uint8_t *bitstream;

  314.     int bitstream_size;

  315. 

  316.     VLC     vlc[2];

  317.     VLC     mv_vlc[2][16];

  318. 

  319.     int     qtab[2][64];

  320.     uint8_t pre[32];

  321.     MotionXY *motion;

  322.     int     motion_size;

  323. 

  324.     BswapDSPContext bdsp;

  325. } MobiClipContext;

  326. 

  327. static av_cold int mobiclip_init(AVCodecContext *avctx)

  328. {

  329.     MobiClipContext *s = avctx->priv_data;

  330.     int ret;

  331. 

  332.     if (avctx->width & 15 || avctx->height & 15) {

  333.         av_log(avctx, AV_LOG_ERROR, "width/height not multiple of 16\n");

  334.         return AVERROR_INVALIDDATA;

  335.     }

  336. 

  337.     ff_bswapdsp_init(&s->bdsp);

  338. 

  339.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  340. 

  341.     ret = ff_init_vlc_sparse(&s->vlc[0], 12, 104,

  342.                              bits0,  sizeof(*bits0),  sizeof(*bits0),

  343.                              codes0, sizeof(*codes0), sizeof(*codes0),

  344.                              syms0,  sizeof(*syms0),  sizeof(*syms0), 0);

  345.     if (ret < 0)

  346.         return ret;

  347. 

  348.     ret = ff_init_vlc_sparse(&s->vlc[1], 12, 104,

  349.                              bits0,  sizeof(*bits0),  sizeof(*bits0),

  350.                              codes0, sizeof(*codes0), sizeof(*codes0),

  351.                              syms1,  sizeof(*syms1),  sizeof(*syms1), 0);

  352.     if (ret < 0)

  353.         return ret;

  354. 

  355.     s->motion = av_calloc(avctx->width / 16 + 3, sizeof(MotionXY));

  356.     if (!s->motion)

  357.         return AVERROR(ENOMEM);

  358.     s->motion_size = (avctx->width / 16 + 3) * sizeof(MotionXY);

  359. 

  360.     for (int i = 0; i < 6; i++) {

  361.         s->pic[i] = av_frame_alloc();

  362.         if (!s->pic[i])

  363.             return AVERROR(ENOMEM);

  364.     }

  365. 

  366.     for (int j = 0; j < 16; j++) {

  367.         ret = ff_init_vlc_sparse(&s->mv_vlc[0][j], 8, mv_len[j],

  368.                                  mv_bits_mods[j],  sizeof(*mv_bits_mods[j]),  sizeof(*mv_bits_mods[j]),

  369.                                  mv_codes_mods[j], sizeof(*mv_codes_mods[j]), sizeof(*mv_codes_mods[j]),

  370.                                  mv_syms_mods[j],  sizeof(*mv_syms_mods[j]),  sizeof(*mv_syms_mods[j]), 0);

  371.         if (ret < 0)

  372.             return ret;

  373. 

  374.         ret = ff_init_vlc_sparse(&s->mv_vlc[1][j], 8, mv_len[j],

  375.                                  mv_bits[j],  sizeof(*mv_bits[j]),  sizeof(*mv_bits[j]),

  376.                                  mv_codes[j], sizeof(*mv_codes[j]), sizeof(*mv_codes[j]),

  377.                                  mv_syms[j],  sizeof(*mv_syms[j]),  sizeof(*mv_syms[j]), 0);

  378.         if (ret < 0)

  379.             return ret;

  380.     }

  381. 

  382.     return 0;

  383. }

  384. 

  385. static void setup_qtables(AVCodecContext *avctx, int quantizer)

  386. {

  387.     MobiClipContext *s = avctx->priv_data;

  388.     int qx, qy;

  389. 

  390.     s->quantizer = quantizer;

  391. 

  392.     qx = quantizer % 6;

  393.     qy = quantizer / 6;

  394. 

  395.     for (int i = 0; i < 16; i++)

  396.         s->qtab[0][i] = quant4x4_tab[qx][i] << qy;

  397. 

  398.     for (int i = 0; i < 64; i++)

  399.         s->qtab[1][i] = quant8x8_tab[qx][i] << (qy - 2);

  400. 

  401.     for (int i = 0; i < 20; i++)

  402.         s->pre[i] = 9;

  403. }

  404. 

  405. static void inverse4(int *rs)

  406. {

  407.     int a = rs[0] + rs[2];

  408.     int b = rs[0] - rs[2];

  409.     int c = rs[1] + (rs[3] >> 1);

  410.     int d = (rs[1] >> 1) - rs[3];

  411. 

  412.     rs[0] = a + c;

  413.     rs[1] = b + d;

  414.     rs[2] = b - d;

  415.     rs[3] = a - c;

  416. }

  417. 

  418. static void idct(int *arr, int size)

  419. {

  420.     int e, f, g, h, x3, x2, x1, x0;

  421.     int tmp[4];

  422. 

  423.     if (size == 4) {

  424.         inverse4(arr);

  425.         return;

  426.     }

  427. 

  428.     tmp[0] = arr[0];

  429.     tmp[1] = arr[2];

  430.     tmp[2] = arr[4];

  431.     tmp[3] = arr[6];

  432. 

  433.     inverse4(tmp);

  434. 

  435.     e = arr[7] + arr[1] - arr[3] - (arr[3] >> 1);

  436.     f = arr[7] - arr[1] + arr[5] + (arr[5] >> 1);

  437.     g = arr[5] - arr[3] - arr[7] - (arr[7] >> 1);

  438.     h = arr[5] + arr[3] + arr[1] + (arr[1] >> 1);

  439.     x3 = g + (h >> 2);

  440.     x2 = e + (f >> 2);

  441.     x1 = (e >> 2) - f;

  442.     x0 = h - (g >> 2);

  443. 

  444.     arr[0] = tmp[0] + x0;

  445.     arr[1] = tmp[1] + x1;

  446.     arr[2] = tmp[2] + x2;

  447.     arr[3] = tmp[3] + x3;

  448.     arr[4] = tmp[3] - x3;

  449.     arr[5] = tmp[2] - x2;

  450.     arr[6] = tmp[1] - x1;

  451.     arr[7] = tmp[0] - x0;

  452. }

  453. 

  454. static int read_run_encoding(AVCodecContext *avctx,

  455.                               int *last, int *run, int *level)

  456. {

  457.     MobiClipContext *s = avctx->priv_data;

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

  459.     int n = get_vlc2(gb, s->vlc[s->dct_tab_idx].table,

  460.                      s->vlc[s->dct_tab_idx].bits, 2);

  461. 

  462.     if (n < 0)

  463.         return AVERROR_INVALIDDATA;

  464. 

  465.     *last = (n >> 11) == 1;

  466.     *run  = (n >> 5) & 0x3F;

  467.     *level = n & 0x1F;

  468. 

  469.     return 0;

  470. }

  471. 

  472. static int add_coefficients(AVCodecContext *avctx, AVFrame *frame,

  473.                             int bx, int by, int size, int plane)

  474. {

  475.     MobiClipContext *s = avctx->priv_data;

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

  477.     int mat[64] = { 0 };

  478.     const uint8_t *ztab = size == 8 ? ff_zigzag_direct : zigzag4x4_tab;

  479.     const int *qtab = s->qtab[size == 8];

  480.     uint8_t *dst = frame->data[plane] + by * frame->linesize[plane] + bx;

  481.     int ret = 0;

  482. 

  483.     for (int pos = 0; get_bits_left(gb) > 0; pos++) {

  484.         int qval, last, run, level;

  485. 

  486.         ret = read_run_encoding(avctx, &last, &run, &level);

  487.         if (ret < 0)

  488.             return ret;

  489. 

  490.         if (level) {

  491.             if (get_bits1(gb))

  492.                 level = -level;

  493.         } else if (!get_bits1(gb)) {

  494.             ret = read_run_encoding(avctx, &last, &run, &level);

  495.             if (ret < 0)

  496.                 return ret;

  497.             level += run_residue[s->dct_tab_idx][(last ? 64 : 0) + run];

  498.             if (get_bits1(gb))

  499.                 level = -level;

  500.         } else if (!get_bits1(gb)) {

  501.             ret = read_run_encoding(avctx, &last, &run, &level);

  502.             if (ret < 0)

  503.                 return ret;

  504.             run += run_residue[s->dct_tab_idx][128 + (last ? 64 : 0) + level];

  505.             if (get_bits1(gb))

  506.                 level = -level;

  507.         } else {

  508.             last  = get_bits1(gb);

  509.             run   = get_bits(gb, 6);

  510.             level = get_sbits(gb, 12);

  511.         }

  512. 

  513.         pos += run;

  514.         if (pos >= size * size)

  515.             return AVERROR_INVALIDDATA;

  516.         qval = qtab[pos];

  517.         mat[ztab[pos]] = qval * level;

  518. 

  519.         if (last)

  520.             break;

  521.     }

  522. 

  523.     mat[0] += 32;

  524.     for (int y = 0; y < size; y++)

  525.         idct(&mat[y * size], size);

  526. 

  527.     for (int y = 0; y < size; y++) {

  528.         for (int x = y + 1; x < size; x++) {

  529.             int a = mat[x * size + y];

  530.             int b = mat[y * size + x];

  531. 

  532.             mat[y * size + x] = a;

  533.             mat[x * size + y] = b;

  534.         }

  535. 

  536.         idct(&mat[y * size], size);

  537.         for (int x = 0; x < size; x++)

  538.             dst[x] = av_clip_uint8(dst[x] + (mat[y * size + x] >> 6));

  539.         dst += frame->linesize[plane];

  540.     }

  541. 

  542.     return ret;

  543. }

  544. 

  545. static int add_pframe_coefficients(AVCodecContext *avctx, AVFrame *frame,

  546.                                    int bx, int by, int size, int plane)

  547. {

  548.     MobiClipContext *s = avctx->priv_data;

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

  550.     int ret, idx = get_ue_golomb(gb);

  551. 

  552.     if (idx == 0) {

  553.         ret = add_coefficients(avctx, frame, bx, by, size, plane);

  554.     } else if (idx < FF_ARRAY_ELEMS(pframe_block4x4_coefficients_tab)) {

  555.         int flags = pframe_block4x4_coefficients_tab[idx];

  556. 

  557.         for (int y = by; y < by + 8; y += 4) {

  558.             for (int x = bx; x < bx + 8; x += 4) {

  559.                 if (flags & 1) {

  560.                     ret = add_coefficients(avctx, frame, x, y, 4, plane);

  561.                     if (ret < 0)

  562.                         return ret;

  563.                 }

  564.                 flags >>= 1;

  565.             }

  566.         }

  567.     } else {

  568.         ret = AVERROR_INVALIDDATA;

  569.     }

  570. 

  571.     return ret;

  572. }

  573. 

  574. static int adjust(int x, int size)

  575. {

  576.     return size == 16 ? (x + 1) >> 1 : x;

  577. }

  578. 

  579. static uint8_t pget(BlockXY b)

  580. {

  581.     BlockXY ret = b;

  582.     int x, y;

  583. 

  584.     if (b.x == -1 && b.y >= b.size) {

  585.         ret.x = -1, ret.y = b.size - 1;

  586.     } else if (b.x >= -1 && b.y >= -1) {

  587.         ret.x = b.x, ret.y = b.y;

  588.     } else if (b.x == -1 && b.y == -2) {

  589.         ret.x = 0, ret.y = -1;

  590.     } else if (b.x == -2 && b.y == -1) {

  591.         ret.x = -1, ret.y = 0;

  592.     }

  593. 

  594.     y = av_clip(ret.ay + ret.y, 0, ret.h - 1);

  595.     x = av_clip(ret.ax + ret.x, 0, ret.w - 1);

  596. 

  597.     return ret.block[y * ret.linesize + x];

  598. }

  599. 

  600. static uint8_t half(int a, int b)

  601. {

  602.     return ((a + b) + 1) / 2;

  603. }

  604. 

  605. static uint8_t half3(int a, int b, int c)

  606. {

  607.     return ((a + b + b + c) * 2 / 4 + 1) / 2;;

  608. }

  609. 

  610. static uint8_t pick_above(BlockXY bxy)

  611. {

  612.     bxy.y = bxy.y - 1;

  613. 

  614.     return pget(bxy);

  615. }

  616. 

  617. static uint8_t pick_left(BlockXY bxy)

  618. {

  619.     bxy.x = bxy.x - 1;

  620. 

  621.     return pget(bxy);

  622. }

  623. 

  624. static uint8_t half_horz(BlockXY bxy)

  625. {

  626.     BlockXY a = bxy, b = bxy, c = bxy;

  627. 

  628.     a.x -= 1;

  629.     c.x += 1;

  630. 

  631.     return half3(pget(a), pget(b), pget(c));

  632. }

  633. 

  634. static uint8_t half_vert(BlockXY bxy)

  635. {

  636.     BlockXY a = bxy, b = bxy, c = bxy;

  637. 

  638.     a.y -= 1;

  639.     c.y += 1;

  640. 

  641.     return half3(pget(a), pget(b), pget(c));

  642. }

  643. 

  644. static uint8_t pick_4(BlockXY bxy)

  645. {

  646.     int val;

  647. 

  648.     if ((bxy.x % 2) == 0) {

  649.         BlockXY ba, bb;

  650.         int a, b;

  651. 

  652.         ba = bxy;

  653.         ba.x = -1;

  654.         ba.y = bxy.y + bxy.x / 2;

  655.         a = pget(ba);

  656. 

  657.         bb = bxy;

  658.         bb.x = -1;

  659.         bb.y = bxy.y + bxy.x / 2 + 1;

  660.         b = pget(bb);

  661. 

  662.         val = half(a, b);

  663.     } else {

  664.         BlockXY ba;

  665. 

  666.         ba = bxy;

  667.         ba.x = -1;

  668.         ba.y = bxy.y + bxy.x / 2 + 1;

  669.         val = half_vert(ba);

  670.     }

  671. 

  672.     return val;

  673. }

  674. 

  675. static uint8_t pick_5(BlockXY bxy)

  676. {

  677.     int val;

  678. 

  679.     if (bxy.x == 0) {

  680.         BlockXY a = bxy;

  681.         BlockXY b = bxy;

  682. 

  683.         a.x = -1;

  684.         a.y -= 1;

  685. 

  686.         b.x = -1;

  687. 

  688.         val = half(pget(a), pget(b));

  689.     } else if (bxy.y == 0) {

  690.         BlockXY a = bxy;

  691. 

  692.         a.x -= 2;

  693.         a.y -= 1;

  694. 

  695.         val = half_horz(a);

  696.     } else if (bxy.x == 1) {

  697.         BlockXY a = bxy;

  698. 

  699.         a.x -= 2;

  700.         a.y -= 1;

  701. 

  702.         val = half_vert(a);

  703.     } else {

  704.         BlockXY a = bxy;

  705. 

  706.         a.x -= 2;

  707.         a.y -= 1;

  708. 

  709.         val = pget(a);

  710.     }

  711. 

  712.     return val;

  713. }

  714. 

  715. static uint8_t pick_6(BlockXY bxy)

  716. {

  717.     int val;

  718. 

  719.     if (bxy.y == 0) {

  720.         BlockXY a = bxy;

  721.         BlockXY b = bxy;

  722. 

  723.         a.x -= 1;

  724.         a.y = -1;

  725. 

  726.         b.y = -1;

  727. 

  728.         val = half(pget(a), pget(b));

  729.     } else if (bxy.x == 0) {

  730.         BlockXY a = bxy;

  731. 

  732.         a.x -= 1;

  733.         a.y -= 2;

  734. 

  735.         val = half_vert(a);

  736.     } else if (bxy.y == 1) {

  737.         BlockXY a = bxy;

  738. 

  739.         a.x -= 1;

  740.         a.y -= 2;

  741. 

  742.         val = half_horz(a);

  743.     } else {

  744.         BlockXY a = bxy;

  745. 

  746.         a.x -= 1;

  747.         a.y -= 2;

  748. 

  749.         val = pget(a);

  750.     }

  751. 

  752.     return val;

  753. }

  754. 

  755. static uint8_t pick_7(BlockXY bxy)

  756. {

  757.     int clr, acc1, acc2;

  758.     BlockXY a = bxy;

  759. 

  760.     a.x -= 1;

  761.     a.y -= 1;

  762.     clr = pget(a);

  763.     if (bxy.x && bxy.y)

  764.         return clr;

  765. 

  766.     if (bxy.x == 0) {

  767.         a.x = -1;

  768.         a.y = bxy.y;

  769.     } else {

  770.         a.x = bxy.x - 2;

  771.         a.y = -1;

  772.     }

  773.     acc1 = pget(a);

  774. 

  775.     if (bxy.y == 0) {

  776.         a.x = bxy.x;

  777.         a.y = -1;

  778.     } else {

  779.         a.x = -1;

  780.         a.y = bxy.y - 2;

  781.     }

  782.     acc2 = pget(a);

  783. 

  784.     return half3(acc1, clr, acc2);

  785. }

  786. 

  787. static uint8_t pick_8(BlockXY bxy)

  788. {

  789.     BlockXY ba = bxy;

  790.     BlockXY bb = bxy;

  791.     int val;

  792. 

  793.     if (bxy.y == 0) {

  794.         int a, b;

  795. 

  796.         ba.y = -1;

  797.         a = pget(ba);

  798. 

  799.         bb.x += 1;

  800.         bb.y = -1;

  801. 

  802.         b = pget(bb);

  803. 

  804.         val = half(a, b);

  805.     } else if (bxy.y == 1) {

  806.         ba.x += 1;

  807.         ba.y -= 2;

  808. 

  809.         val = half_horz(ba);

  810.     } else if (bxy.x < bxy.size - 1) {

  811.         ba.x += 1;

  812.         ba.y -= 2;

  813. 

  814.         val = pget(ba);

  815.     } else if (bxy.y % 2 == 0) {

  816.         int a, b;

  817. 

  818.         ba.x = bxy.y / 2 + bxy.size - 1;

  819.         ba.y = -1;

  820.         a = pget(ba);

  821. 

  822.         bb.x = bxy.y / 2 + bxy.size;

  823.         bb.y = -1;

  824. 

  825.         b = pget(bb);

  826. 

  827.         val = half(a, b);

  828.     } else {

  829.         ba.x = bxy.y / 2 + bxy.size;

  830.         ba.y = -1;

  831. 

  832.         val = half_horz(ba);

  833.     }

  834. 

  835.     return val;

  836. }

  837. 

  838. static void block_fill_simple(uint8_t *block, int size, int linesize, int fill)

  839. {

  840.     for (int y = 0; y < size; y++) {

  841.         memset(block, fill, size);

  842.         block += linesize;

  843.     }

  844. }

  845. 

  846. static void block_fill(uint8_t *block, int size, int linesize,

  847.                        int w, int h, int ax, int ay,

  848.                        uint8_t (*pick)(BlockXY bxy))

  849. {

  850.     BlockXY bxy;

  851. 

  852.     bxy.size = size;

  853.     bxy.block = block;

  854.     bxy.linesize = linesize;

  855.     bxy.w = w;

  856.     bxy.h = h;

  857.     bxy.ay = ay;

  858.     bxy.ax = ax;

  859. 

  860.     for (int y = 0; y < size; y++) {

  861.         bxy.y = y;

  862.         for (int x = 0; x < size; x++) {

  863.             uint8_t val;

  864. 

  865.             bxy.x = x;

  866. 

  867.             val = pick(bxy);

  868. 

  869.             block[ax + x + (ay + y) * linesize] = val;

  870.         }

  871.     }

  872. }

  873. 

  874. static int block_sum(const uint8_t *block, int w, int h, int linesize)

  875. {

  876.     int sum = 0;

  877. 

  878.     for (int y = 0; y < h; y++) {

  879.         for (int x = 0; x < w; x++) {

  880.             sum += block[x];

  881.         }

  882.         block += linesize;

  883.     }

  884. 

  885.     return sum;

  886. }

  887. 

  888. static int predict_intra(AVCodecContext *avctx, AVFrame *frame, int ax, int ay,

  889.                           int pmode, int add_coeffs, int size, int plane)

  890. {

  891.     MobiClipContext *s = avctx->priv_data;

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

  893.     int w = avctx->width >> !!plane, h = avctx->height >> !!plane;

  894.     int ret = 0;

  895. 

  896.     switch (pmode) {

  897.     case 0:

  898.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_above);

  899.         break;

  900.     case 1:

  901.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_left);

  902.         break;

  903.     case 2:

  904.         {

  905.             int arr1[16];

  906.             int arr2[16];

  907.             uint8_t *top = frame->data[plane] + FFMAX(ay - 1, 0) * frame->linesize[plane] + ax;

  908.             uint8_t *left = frame->data[plane] + ay * frame->linesize[plane] + ax - 1;

  909.             int bottommost = frame->data[plane][(ay + size - 1) * frame->linesize[plane] + FFMAX(ax - 1, 0)];

  910.             int rightmost = frame->data[plane][FFMAX(ay - 1, 0) * frame->linesize[plane] + ax + size - 1];

  911.             int avg = (bottommost + rightmost + 1) / 2 + 2 * get_se_golomb(gb);

  912.             int r6 = adjust(avg - bottommost, size);

  913.             int r9 = adjust(avg - rightmost, size);

  914.             int shift = adjust(size, size) == 8 ? 3 : 2;

  915.             uint8_t *block;

  916. 

  917.             for (int x = 0; x < size; x++) {

  918.                 int val = top[x];

  919.                 arr1[x] = adjust(((bottommost - val) * (1 << shift)) + r6 * (x + 1), size);

  920.             }

  921. 

  922.             for (int y = 0; y < size; y++) {

  923.                 int val = left[y * frame->linesize[plane]];

  924.                 arr2[y] = adjust(((rightmost - val) * (1 << shift)) + r9 * (y + 1), size);

  925.             }

  926. 

  927.             block = frame->data[plane] + ay * frame->linesize[plane] + ax;

  928.             for (int y = 0; y < size; y++) {

  929.                 for (int x = 0; x < size; x++) {

  930.                     block[x] = (((top[x] + left[0] + ((arr1[x] * (y + 1) +

  931.                                                        arr2[y] * (x + 1)) >> 2 * shift)) + 1) / 2) & 0xFF;

  932.                 }

  933.                 block += frame->linesize[plane];

  934.                 left  += frame->linesize[plane];

  935.             }

  936.         }

  937.         break;

  938.     case 3:

  939.         {

  940.             uint8_t fill;

  941. 

  942.             if (ax == 0 && ay == 0) {

  943.                 fill = 0x80;

  944.             } else if (ax >= 1 && ay >= 1) {

  945.                 int left = block_sum(frame->data[plane] + ay * frame->linesize[plane] + ax - 1,

  946.                                      1, size, frame->linesize[plane]);

  947.                 int top  = block_sum(frame->data[plane] + (ay - 1) * frame->linesize[plane] + ax,

  948.                                      size, 1, frame->linesize[plane]);

  949. 

  950.                 fill = ((left + top) * 2 / (2 * size) + 1) / 2;

  951.             } else if (ax >= 1) {

  952.                 fill = (block_sum(frame->data[plane] + ay * frame->linesize[plane] + ax - 1,

  953.                                   1, size, frame->linesize[plane]) * 2 / size + 1) / 2;

  954.             } else if (ay >= 1) {

  955.                 fill = (block_sum(frame->data[plane] + (ay - 1) * frame->linesize[plane] + ax,

  956.                                   size, 1, frame->linesize[plane]) * 2 / size + 1) / 2;

  957.             } else {

  958.                 return -1;

  959.             }

  960. 

  961.             block_fill_simple(frame->data[plane] + ay * frame->linesize[plane] + ax,

  962.                               size, frame->linesize[plane], fill);

  963.         }

  964.         break;

  965.     case 4:

  966.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_4);

  967.         break;

  968.     case 5:

  969.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_5);

  970.         break;

  971.     case 6:

  972.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_6);

  973.         break;

  974.     case 7:

  975.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_7);

  976.         break;

  977.     case 8:

  978.         block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_8);

  979.         break;

  980.     }

  981. 

  982.     if (add_coeffs)

  983.         ret = add_coefficients(avctx, frame, ax, ay, size, plane);

  984. 

  985.     return ret;

  986. }

  987. 

  988. static int get_prediction(AVCodecContext *avctx, int x, int y, int size)

  989. {

  990.     MobiClipContext *s = avctx->priv_data;

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

  992.     int index = (y & 0xC) | (x / 4 % 4);

  993. 

  994.     uint8_t val = FFMIN(s->pre[index], index % 4 == 0 ? 9 : s->pre[index + 3]);

  995.     if (val == 9)

  996.         val = 3;

  997. 

  998.     if (!get_bits1(gb)) {

  999.         int x = get_bits(gb, 3);

  1000.         val = x + (x >= val ? 1 : 0);

  1001.     }

  1002. 

  1003.     s->pre[index + 4] = val;

  1004.     if (size == 8)

  1005.         s->pre[index + 5] = s->pre[index + 8] = s->pre[index + 9] = val;

  1006. 

  1007.     return val;

  1008. }

  1009. 

  1010. static int process_block(AVCodecContext *avctx, AVFrame *frame,

  1011.                          int x, int y, int pmode, int has_coeffs, int plane)

  1012. {

  1013.     MobiClipContext *s = avctx->priv_data;

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

  1015.     int tmp, ret;

  1016. 

  1017.     if (!has_coeffs) {

  1018.         if (pmode < 0)

  1019.             pmode = get_prediction(avctx, x, y, 8);

  1020.         return predict_intra(avctx, frame, x, y, pmode, 0, 8, plane);

  1021.     }

  1022. 

  1023.     tmp = get_ue_golomb(gb);

  1024.     if (tmp < 0 || tmp > FF_ARRAY_ELEMS(block4x4_coefficients_tab))

  1025.         return AVERROR_INVALIDDATA;

  1026. 

  1027.     if (tmp == 0) {

  1028.         if (pmode < 0)

  1029.             pmode = get_prediction(avctx, x, y, 8);

  1030.         ret = predict_intra(avctx, frame, x, y, pmode, 1, 8, plane);

  1031.     } else {

  1032.         int flags = block4x4_coefficients_tab[tmp - 1];

  1033. 

  1034.         for (int by = y; by < y + 8; by += 4) {

  1035.             for (int bx = x; bx < x + 8; bx += 4) {

  1036.                 int new_pmode = pmode;

  1037. 

  1038.                 if (new_pmode < 0)

  1039.                     new_pmode = get_prediction(avctx, bx, by, 4);

  1040.                 ret = predict_intra(avctx, frame, bx, by, new_pmode, flags & 1, 4, plane);

  1041.                 if (ret < 0)

  1042.                     return ret;

  1043.                 flags >>= 1;

  1044.             }

  1045.         }

  1046.     }

  1047. 

  1048.     return ret;

  1049. }

  1050. 

  1051. static int decode_macroblock(AVCodecContext *avctx, AVFrame *frame,

  1052.                              int x, int y, int predict)

  1053. {

  1054.     MobiClipContext *s = avctx->priv_data;

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

  1056.     int flags, pmode_uv, idx = get_ue_golomb(gb);

  1057.     int ret = 0;

  1058. 

  1059.     if (idx < 0 || idx >= FF_ARRAY_ELEMS(block8x8_coefficients_tab))

  1060.         return AVERROR_INVALIDDATA;

  1061. 

  1062.     flags = block8x8_coefficients_tab[idx];

  1063. 

  1064.     if (predict) {

  1065.         ret = process_block(avctx, frame, x, y, -1, flags & 1, 0);

  1066.         if (ret < 0)

  1067.             return ret;

  1068.         flags >>= 1;

  1069.         ret = process_block(avctx, frame, x + 8, y, -1, flags & 1, 0);

  1070.         if (ret < 0)

  1071.             return ret;

  1072.         flags >>= 1;

  1073.         ret = process_block(avctx, frame, x, y + 8, -1, flags & 1, 0);

  1074.         if (ret < 0)

  1075.             return ret;

  1076.         flags >>= 1;

  1077.         ret = process_block(avctx, frame, x + 8, y + 8, -1, flags & 1, 0);

  1078.         if (ret < 0)

  1079.             return ret;

  1080.         flags >>= 1;

  1081.     } else {

  1082.         int pmode = get_bits(gb, 3);

  1083. 

  1084.         if (pmode == 2) {

  1085.             ret = predict_intra(avctx, frame, x, y, pmode, 0, 16, 0);

  1086.             if (ret < 0)

  1087.                 return ret;

  1088.             pmode = 9;

  1089.         }

  1090. 

  1091.         ret = process_block(avctx, frame, x, y, pmode, flags & 1, 0);

  1092.         if (ret < 0)

  1093.             return ret;

  1094.         flags >>= 1;

  1095.         ret = process_block(avctx, frame, x + 8, y, pmode, flags & 1, 0);

  1096.         if (ret < 0)

  1097.             return ret;

  1098.         flags >>= 1;

  1099.         ret = process_block(avctx, frame, x, y + 8, pmode, flags & 1, 0);

  1100.         if (ret < 0)

  1101.             return ret;

  1102.         flags >>= 1;

  1103.         ret = process_block(avctx, frame, x + 8, y + 8, pmode, flags & 1, 0);

  1104.         if (ret < 0)

  1105.             return ret;

  1106.         flags >>= 1;

  1107.     }

  1108. 

  1109.     pmode_uv = get_bits(gb, 3);

  1110.     if (pmode_uv == 2) {

  1111.         ret = predict_intra(avctx, frame, x >> 1, y >> 1, pmode_uv, 0, 8, 1 + !s->moflex);

  1112.         if (ret < 0)

  1113.             return ret;

  1114.         ret = predict_intra(avctx, frame, x >> 1, y >> 1, pmode_uv, 0, 8, 2 - !s->moflex);

  1115.         if (ret < 0)

  1116.             return ret;

  1117.         pmode_uv = 9;

  1118.     }

  1119. 

  1120.     ret = process_block(avctx, frame, x >> 1, y >> 1, pmode_uv, flags & 1, 1 + !s->moflex);

  1121.     if (ret < 0)

  1122.         return ret;

  1123.     flags >>= 1;

  1124.     ret = process_block(avctx, frame, x >> 1, y >> 1, pmode_uv, flags & 1, 2 - !s->moflex);

  1125.     if (ret < 0)

  1126.         return ret;

  1127. 

  1128.     return 0;

  1129. }

  1130. 

  1131. static int get_index(int x)

  1132. {

  1133.     return x == 16 ? 0 : x == 8 ? 1 : x == 4 ? 2 : x == 2 ? 3 : 0;

  1134. }

  1135. 

  1136. static int predict_motion(AVCodecContext *avctx,

  1137.                           int width, int height, int index,

  1138.                           int offsetm, int offsetx, int offsety)

  1139. {

  1140.     MobiClipContext *s = avctx->priv_data;

  1141.     MotionXY *motion = s->motion;

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

  1143.     int fheight = avctx->height;

  1144.     int fwidth = avctx->width;

  1145. 

  1146.     if (index <= 5) {

  1147.         int sidx = -FFMAX(1, index) + s->current_pic;

  1148.         MotionXY mv = s->motion[0];

  1149. 

  1150.         if (sidx < 0)

  1151.             sidx += 6;

  1152. 

  1153.         if (index > 0) {

  1154.             mv.x = mv.x + get_se_golomb(gb);

  1155.             mv.y = mv.y + get_se_golomb(gb);

  1156.         }

  1157. 

  1158.         motion[offsetm].x = mv.x;

  1159.         motion[offsetm].y = mv.y;

  1160. 

  1161.         for (int i = 0; i < 3; i++) {

  1162.             int method, src_linesize, dst_linesize;

  1163.             uint8_t *src, *dst;

  1164. 

  1165.             if (i == 1) {

  1166.                 offsetx = offsetx >> 1;

  1167.                 offsety = offsety >> 1;

  1168.                 mv.x = mv.x >> 1;

  1169.                 mv.y = mv.y >> 1;

  1170.                 width = width >> 1;

  1171.                 height = height >> 1;

  1172.                 fwidth = fwidth >> 1;

  1173.                 fheight = fheight >> 1;

  1174.             }

  1175. 

  1176.             av_assert0(s->pic[sidx]);

  1177.             av_assert0(s->pic[s->current_pic]);

  1178.             av_assert0(s->pic[s->current_pic]->data[i]);

  1179.             if (!s->pic[sidx]->data[i])

  1180.                 return AVERROR_INVALIDDATA;

  1181. 

  1182.             method = (mv.x & 1) | ((mv.y & 1) << 1);

  1183.             src_linesize = s->pic[sidx]->linesize[i];

  1184.             dst_linesize = s->pic[s->current_pic]->linesize[i];

  1185.             dst = s->pic[s->current_pic]->data[i] + offsetx + offsety * dst_linesize;

  1186. 

  1187.             switch (method) {

  1188.             case 0:

  1189.                 if (offsety + (mv.y >> 1) < 0 ||

  1190.                     offsety + (mv.y >> 1) >= fheight ||

  1191.                     offsetx + (mv.x >> 1) < 0 ||

  1192.                     offsetx + (mv.x >> 1) >= fwidth)

  1193.                     return AVERROR_INVALIDDATA;

  1194. 

  1195.                 src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +

  1196.                                (offsety + (mv.y >> 1)) * src_linesize;

  1197.                 for (int y = 0; y < height; y++) {

  1198.                     for (int x = 0; x < width; x++)

  1199.                         dst[x] = src[x];

  1200.                     dst += dst_linesize;

  1201.                     src += src_linesize;

  1202.                 }

  1203.                 break;

  1204.             case 1:

  1205.                 if (offsety + (mv.y >> 1) < 0 ||

  1206.                     offsety + (mv.y >> 1) >= fheight ||

  1207.                     offsetx + (mv.x >> 1) < 0 ||

  1208.                     offsetx + (mv.x >> 1) >= fwidth)

  1209.                     return AVERROR_INVALIDDATA;

  1210. 

  1211.                 src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +

  1212.                                (offsety + (mv.y >> 1)) * src_linesize;

  1213.                 for (int y = 0; y < height; y++) {

  1214.                     for (int x = 0; x < width; x++) {

  1215.                         dst[x] = (uint8_t)((src[x] >> 1) + (src[x + 1] >> 1));

  1216.                     }

  1217. 

  1218.                     dst += dst_linesize;

  1219.                     src += src_linesize;

  1220.                 }

  1221.                 break;

  1222.             case 2:

  1223.                 if (offsety + (mv.y >> 1) < 0 ||

  1224.                     offsety + (mv.y >> 1) >= fheight - 1 ||

  1225.                     offsetx + (mv.x >> 1) < 0 ||

  1226.                     offsetx + (mv.x >> 1) >= fwidth)

  1227.                     return AVERROR_INVALIDDATA;

  1228. 

  1229.                 src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +

  1230.                                (offsety + (mv.y >> 1)) * src_linesize;

  1231.                 for (int y = 0; y < height; y++) {

  1232.                     for (int x = 0; x < width; x++) {

  1233.                         dst[x] = (uint8_t)((src[x] >> 1) + (src[x + src_linesize] >> 1));

  1234.                     }

  1235. 

  1236.                     dst += dst_linesize;

  1237.                     src += src_linesize;

  1238.                 }

  1239.                 break;

  1240.             case 3:

  1241.                 if (offsety + (mv.y >> 1) < 0 ||

  1242.                     offsety + (mv.y >> 1) >= fheight - 1 ||

  1243.                     offsetx + (mv.x >> 1) < 0 ||

  1244.                     offsetx + (mv.x >> 1) >= fwidth)

  1245.                     return AVERROR_INVALIDDATA;

  1246. 

  1247.                 src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +

  1248.                                (offsety + (mv.y >> 1)) * src_linesize;

  1249.                 for (int y = 0; y < height; y++) {

  1250.                     for (int x = 0; x < width; x++) {

  1251.                         dst[x] = (uint8_t)((((src[x] >> 1) + (src[x + 1] >> 1)) >> 1) +

  1252.                                            (((src[x + src_linesize] >> 1) + (src[x + 1 + src_linesize] >> 1)) >> 1));

  1253.                     }

  1254. 

  1255.                     dst += dst_linesize;

  1256.                     src += src_linesize;

  1257.                 }

  1258.                 break;

  1259.             }

  1260.         }

  1261.     } else {

  1262.         int tidx;

  1263.         int adjx = index == 8 ? 0 :  width / 2;

  1264.         int adjy = index == 8 ? height / 2 : 0;

  1265. 

  1266.         width  = width  - adjx;

  1267.         height = height - adjy;

  1268.         tidx = get_index(height) * 4 + get_index(width);

  1269. 

  1270.         for (int i = 0; i < 2; i++) {

  1271.             int ret, idx2;

  1272. 

  1273.             idx2 = get_vlc2(gb, s->mv_vlc[s->moflex][tidx].table,

  1274.                             s->mv_vlc[s->moflex][tidx].bits, 1);

  1275.             if (idx2 < 0)

  1276.                 return AVERROR_INVALIDDATA;

  1277. 

  1278.             ret = predict_motion(avctx, width, height, idx2,

  1279.                                  offsetm, offsetx + i * adjx, offsety + i * adjy);

  1280.             if (ret < 0)

  1281.                 return ret;

  1282.         }

  1283.     }

  1284. 

  1285.     return 0;

  1286. }

  1287. 

  1288. static int mobiclip_decode(AVCodecContext *avctx, void *data,

  1289.                             int *got_frame, AVPacket *pkt)

  1290. {

  1291.     MobiClipContext *s = avctx->priv_data;

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

  1293.     AVFrame *frame = s->pic[s->current_pic];

  1294.     int ret;

  1295. 

  1296.     av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,

  1297.                           pkt->size);

  1298. 

  1299.     if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)

  1300.         return ret;

  1301. 

  1302.     s->bdsp.bswap16_buf((uint16_t *)s->bitstream,

  1303.                         (uint16_t *)pkt->data,

  1304.                         (pkt->size + 1) >> 1);

  1305. 

  1306.     ret = init_get_bits8(gb, s->bitstream, s->bitstream_size);

  1307.     if (ret < 0)

  1308.         return ret;

  1309. 

  1310.     if (get_bits1(gb)) {

  1311.         frame->pict_type = AV_PICTURE_TYPE_I;

  1312.         frame->key_frame = 1;

  1313.         s->moflex = get_bits1(gb);

  1314.         s->dct_tab_idx = get_bits1(gb);

  1315. 

  1316.         setup_qtables(avctx, get_bits(gb, 6));

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

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

  1319.                 ret = decode_macroblock(avctx, frame, x, y, get_bits1(gb));

  1320.                 if (ret < 0)

  1321.                     return ret;

  1322.             }

  1323.         }

  1324.     } else {

  1325.         MotionXY *motion = s->motion;

  1326.         int quantizer = s->quantizer + get_se_golomb(gb);

  1327. 

  1328.         if (quantizer < 12 || quantizer > 161)

  1329.             return AVERROR_INVALIDDATA;

  1330. 

  1331.         memset(motion, 0, s->motion_size);

  1332. 

  1333.         frame->pict_type = AV_PICTURE_TYPE_P;

  1334.         frame->key_frame = 0;

  1335.         s->dct_tab_idx = 0;

  1336. 

  1337.         setup_qtables(avctx, quantizer);

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

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

  1340.                 int idx;

  1341. 

  1342.                 motion[0].x = mid_pred(motion[x / 16 + 1].x, motion[x / 16 + 2].x, motion[x / 16 + 3].x);

  1343.                 motion[0].y = mid_pred(motion[x / 16 + 1].y, motion[x / 16 + 2].y, motion[x / 16 + 3].y);

  1344.                 motion[x / 16 + 2].x = 0;

  1345.                 motion[x / 16 + 2].y = 0;

  1346. 

  1347.                 idx = get_vlc2(gb, s->mv_vlc[s->moflex][0].table,

  1348.                                    s->mv_vlc[s->moflex][0].bits, 1);

  1349.                 if (idx < 0)

  1350.                     return AVERROR_INVALIDDATA;

  1351. 

  1352.                 if (idx == 6 || idx == 7) {

  1353.                     ret = decode_macroblock(avctx, frame, x, y, idx == 7);

  1354.                     if (ret < 0)

  1355.                         return ret;

  1356.                 } else {

  1357.                     int flags, idx2;

  1358.                     ret = predict_motion(avctx, 16, 16, idx, x / 16 + 2, x, y);

  1359.                     if (ret < 0)

  1360.                         return ret;

  1361.                     idx2 = get_ue_golomb(gb);

  1362.                     if (idx2 >= FF_ARRAY_ELEMS(pframe_block8x8_coefficients_tab))

  1363.                         return AVERROR_INVALIDDATA;

  1364.                     flags = pframe_block8x8_coefficients_tab[idx2];

  1365. 

  1366.                     for (int sy = y; sy < y + 16; sy += 8) {

  1367.                         for (int sx = x; sx < x + 16; sx += 8) {

  1368.                             if (flags & 1)

  1369.                                 add_pframe_coefficients(avctx, frame, sx, sy, 8, 0);

  1370.                             flags >>= 1;

  1371.                         }

  1372.                     }

  1373. 

  1374.                     if (flags & 1)

  1375.                         add_pframe_coefficients(avctx, frame, x >> 1, y >> 1, 8, 1 + !s->moflex);

  1376.                     flags >>= 1;

  1377.                     if (flags & 1)

  1378.                         add_pframe_coefficients(avctx, frame, x >> 1, y >> 1, 8, 2 - !s->moflex);

  1379.                 }

  1380.             }

  1381.         }

  1382.     }

  1383. 

  1384.     if (!s->moflex)

  1385.         avctx->colorspace = AVCOL_SPC_YCGCO;

  1386. 

  1387.     s->current_pic = (s->current_pic + 1) % 6;

  1388.     ret = av_frame_ref(data, frame);

  1389.     if (ret < 0)

  1390.         return ret;

  1391.     *got_frame = 1;

  1392. 

  1393.     return 0;

  1394. }

  1395. 

  1396. static void mobiclip_flush(AVCodecContext *avctx)

  1397. {

  1398.     MobiClipContext *s = avctx->priv_data;

  1399. 

  1400.     for (int i = 0; i < 6; i++)

  1401.         av_frame_unref(s->pic[i]);

  1402. }

  1403. 

  1404. static av_cold int mobiclip_close(AVCodecContext *avctx)

  1405. {

  1406.     MobiClipContext *s = avctx->priv_data;

  1407. 

  1408.     ff_free_vlc(&s->vlc[0]);

  1409.     ff_free_vlc(&s->vlc[1]);

  1410. 

  1411.     for (int i = 0; i < 16; i++) {

  1412.         ff_free_vlc(&s->mv_vlc[0][i]);

  1413.         ff_free_vlc(&s->mv_vlc[1][i]);

  1414.     }

  1415. 

  1416.     av_freep(&s->bitstream);

  1417.     s->bitstream_size = 0;

  1418.     av_freep(&s->motion);

  1419.     s->motion_size = 0;

  1420. 

  1421.     for (int i = 0; i < 6; i++) {

  1422.         av_frame_free(&s->pic[i]);

  1423.     }

  1424. 

  1425.     return 0;

  1426. }

  1427. 

  1428. AVCodec ff_mobiclip_decoder = {

  1429.     .name           = "mobiclip",

  1430.     .long_name      = NULL_IF_CONFIG_SMALL("MobiClip Video"),

  1431.     .type           = AVMEDIA_TYPE_VIDEO,

  1432.     .id             = AV_CODEC_ID_MOBICLIP,

  1433.     .priv_data_size = sizeof(MobiClipContext),

  1434.     .init           = mobiclip_init,

  1435.     .decode         = mobiclip_decode,

  1436.     .flush          = mobiclip_flush,

  1437.     .close          = mobiclip_close,

  1438.     .capabilities   = AV_CODEC_CAP_DR1,

  1439. };