git.sesse.net Git - ffmpeg/blob - libavcodec/mobiclip.c

   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] + FFMAX(ax - 1, 0);
 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     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1440 };