FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/mobiclip.c
Date: 2022-07-07 01:21:54
Exec Total Coverage
Lines: 0 667 0.0%
Branches: 0 353 0.0%
Line Branch Exec Source
1 /*
2 * MobiClip Video decoder
3 * Copyright (c) 2015-2016 Florian Nouwt
4 * Copyright (c) 2017 Adib Surani
5 * Copyright (c) 2020 Paul B Mahol
6 *
7 * This file is part of FFmpeg.
8 *
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24 #include <inttypes.h>
25
26 #include "libavutil/avassert.h"
27 #include "libavutil/thread.h"
28
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "bswapdsp.h"
32 #include "codec_internal.h"
33 #include "get_bits.h"
34 #include "golomb.h"
35 #include "internal.h"
36
37 #define MOBI_RL_VLC_BITS 12
38 #define MOBI_MV_VLC_BITS 6
39
40 static const uint8_t zigzag4x4_tab[] =
41 {
42 0x00, 0x04, 0x01, 0x02, 0x05, 0x08, 0x0C, 0x09, 0x06, 0x03, 0x07, 0x0A,
43 0x0D, 0x0E, 0x0B, 0x0F
44 };
45
46 static const uint8_t quant4x4_tab[][16] =
47 {
48 { 10, 13, 13, 10, 16, 10, 13, 13, 13, 13, 16, 10, 16, 13, 13, 16 },
49 { 11, 14, 14, 11, 18, 11, 14, 14, 14, 14, 18, 11, 18, 14, 14, 18 },
50 { 13, 16, 16, 13, 20, 13, 16, 16, 16, 16, 20, 13, 20, 16, 16, 20 },
51 { 14, 18, 18, 14, 23, 14, 18, 18, 18, 18, 23, 14, 23, 18, 18, 23 },
52 { 16, 20, 20, 16, 25, 16, 20, 20, 20, 20, 25, 16, 25, 20, 20, 25 },
53 { 18, 23, 23, 18, 29, 18, 23, 23, 23, 23, 29, 18, 29, 23, 23, 29 },
54 };
55
56 static const uint8_t quant8x8_tab[][64] =
57 {
58 { 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,
59 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,},
60 { 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,
61 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,},
62 { 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,
63 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,},
64 { 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,
65 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,},
66 { 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,
67 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,},
68 { 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,
69 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,},
70 };
71
72 static const uint8_t block4x4_coefficients_tab[] =
73 {
74 15, 0, 2, 1, 4, 8, 12, 3, 11, 13, 14, 7, 10, 5, 9, 6,
75 };
76
77 static const uint8_t pframe_block4x4_coefficients_tab[] =
78 {
79 0, 4, 1, 8, 2, 12, 3, 5, 10, 15, 7, 13, 14, 11, 9, 6,
80 };
81
82 static const uint8_t block8x8_coefficients_tab[] =
83 {
84 0x00, 0x1F, 0x3F, 0x0F, 0x08, 0x04, 0x02, 0x01, 0x0B, 0x0E, 0x1B, 0x0D,
85 0x03, 0x07, 0x0C, 0x17, 0x1D, 0x0A, 0x1E, 0x05, 0x10, 0x2F, 0x37, 0x3B,
86 0x13, 0x3D, 0x3E, 0x09, 0x1C, 0x06, 0x15, 0x1A, 0x33, 0x11, 0x12, 0x14,
87 0x18, 0x20, 0x3C, 0x35, 0x19, 0x16, 0x3A, 0x30, 0x31, 0x32, 0x27, 0x34,
88 0x2B, 0x2D, 0x39, 0x38, 0x23, 0x36, 0x2E, 0x21, 0x25, 0x22, 0x24, 0x2C,
89 0x2A, 0x28, 0x29, 0x26,
90 };
91
92 static const uint8_t pframe_block8x8_coefficients_tab[] =
93 {
94 0x00, 0x0F, 0x04, 0x01, 0x08, 0x02, 0x0C, 0x03, 0x05, 0x0A, 0x0D, 0x07, 0x0E, 0x0B, 0x1F, 0x09,
95 0x06, 0x10, 0x3F, 0x1E, 0x17, 0x1D, 0x1B, 0x1C, 0x13, 0x18, 0x1A, 0x12, 0x11, 0x14, 0x15, 0x20,
96 0x2F, 0x16, 0x19, 0x37, 0x3D, 0x3E, 0x3B, 0x3C, 0x33, 0x35, 0x21, 0x24, 0x22, 0x28, 0x23, 0x2C,
97 0x30, 0x27, 0x2D, 0x25, 0x3A, 0x2B, 0x2E, 0x2A, 0x31, 0x34, 0x38, 0x32, 0x29, 0x26, 0x39, 0x36
98 };
99
100 static const uint8_t run_residue[2][256] =
101 {
102 {
103 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,
104 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,
105 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,
106 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,
107 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,
108 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,
109 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,
110 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,
111 },
112 {
113 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,
114 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,
115 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,
116 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,
117 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,
118 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,
119 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,
120 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,
121 },
122 };
123
124 static const uint8_t bits0[] = {
125 9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
126 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12,
127 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 7, 10, 10, 9,
128 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
129 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
130 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6,
131 6, 6, 6, 6, 6, 6, 5, 5, 5, 4, 2, 3, 4, 4,
132 };
133
134 static const uint16_t syms0[] = {
135 0x0, 0x822, 0x803, 0xB, 0xA, 0xB81, 0xB61, 0xB41, 0xB21, 0x122,
136 0x102, 0xE2, 0xC2, 0xA2, 0x63, 0x43, 0x24, 0xC, 0x25, 0x2E1, 0x301,
137 0xBA1, 0xBC1, 0xBE1, 0xC01, 0x26, 0x44, 0x83, 0xA3, 0xC3, 0x142,
138 0x321, 0x341, 0xC21, 0xC41, 0xC61, 0xC81, 0xCA1, 0xCC1, 0xCE1, 0xD01,
139 0x0, 0x9, 0x8, 0xB01, 0xAE1, 0xAC1, 0xAA1, 0xA81, 0xA61, 0xA41, 0xA21,
140 0x802, 0x2C1, 0x2A1, 0x281, 0x261, 0x241, 0x221, 0x201, 0x1E1, 0x82,
141 0x62, 0x7, 0x6, 0xA01, 0x9E1, 0x9C1, 0x9A1, 0x981, 0x961, 0x941, 0x921,
142 0x1C1, 0x1A1, 0x42, 0x23, 0x5, 0x901, 0x8E1, 0x8C1, 0x8A1, 0x181, 0x161,
143 0x141, 0x4, 0x881, 0x861, 0x841, 0x821, 0x121, 0x101, 0xE1, 0xC1, 0x22,
144 0x3, 0xA1, 0x81, 0x61, 0x801, 0x1, 0x21, 0x41, 0x2,
145 };
146
147 static const uint16_t syms1[] = {
148 0x0, 0x807, 0x806, 0x16, 0x15, 0x842, 0x823, 0x805, 0x1A1, 0xA3, 0x102, 0x83,
149 0x64, 0x44, 0x27, 0x14, 0x13, 0x17, 0x18, 0x28, 0x122, 0x862, 0x882, 0x9E1, 0xA01,
150 0x19, 0x1A, 0x1B, 0x29, 0xC3, 0x2A, 0x45, 0xE3, 0x1C1, 0x808, 0x8A2, 0x8C2, 0xA21,
151 0xA41, 0xA61, 0xA81, 0x0, 0x12, 0x11, 0x9C1, 0x9A1, 0x981, 0x961, 0x941, 0x822, 0x804,
152 0x181, 0x161, 0xE2, 0xC2, 0xA2, 0x63, 0x43, 0x26, 0x25, 0x10, 0x82, 0xF, 0xE, 0xD, 0x901,
153 0x8E1, 0x8C1, 0x803, 0x141, 0x121, 0x101, 0x921, 0x62, 0x24, 0xC, 0xB, 0xA, 0x881, 0x861,
154 0xC1, 0x8A1, 0xE1, 0x42, 0x23, 0x9, 0x802, 0xA1, 0x841, 0x821, 0x81, 0x61, 0x8, 0x7, 0x22,
155 0x6, 0x41, 0x5, 0x4, 0x801, 0x1, 0x2, 0x21, 0x3,
156 };
157
158 static const uint8_t mv_len[16] =
159 {
160 10, 8, 8, 7, 8, 8, 8, 7, 8, 8, 8, 7, 7, 7, 7, 6,
161 };
162
163 static const uint8_t mv_bits[2][16][10] =
164 {
165 {
166 { 2, 3, 3, 5, 5, 4, 4, 5, 5, 2 },
167 { 2, 3, 4, 4, 3, 4, 4, 2 },
168 { 3, 4, 4, 2, 4, 4, 3, 2 },
169 { 1, 3, 4, 5, 5, 3, 3 },
170 { 2, 4, 4, 3, 3, 4, 4, 2 },
171 { 2, 3, 4, 4, 4, 4, 3, 2 },
172 { 2, 3, 4, 4, 4, 4, 3, 2 },
173 { 2, 2, 3, 4, 5, 5, 2 },
174 { 2, 3, 4, 4, 3, 4, 4, 2 },
175 { 2, 4, 4, 3, 4, 4, 3, 2 },
176 { 2, 3, 3, 5, 5, 4, 3, 2 },
177 { 2, 3, 4, 4, 3, 3, 2 },
178 { 1, 4, 4, 3, 3, 4, 4 },
179 { 2, 3, 4, 4, 3, 3, 2 },
180 { 2, 3, 4, 4, 3, 3, 2 },
181 { 3, 3, 2, 2, 3, 3 },
182 },
183 {
184 { 3, 4, 5, 5, 3, 5, 6, 6, 4, 1 },
185 { 2, 3, 4, 5, 5, 2, 3, 3 },
186 { 2, 4, 4, 3, 3, 4, 4, 2 },
187 { 1, 4, 4, 3, 4, 4, 3 },
188 { 3, 3, 2, 4, 5, 5, 3, 2 },
189 { 3, 4, 4, 3, 3, 3, 3, 2 },
190 { 1, 3, 3, 4, 4, 4, 5, 5 },
191 { 1, 4, 4, 3, 3, 4, 4 },
192 { 2, 4, 4, 3, 3, 4, 4, 2 },
193 { 1, 3, 3, 4, 4, 4, 5, 5 },
194 { 2, 3, 4, 4, 4, 4, 3, 2 },
195 { 2, 3, 3, 4, 4, 3, 2 },
196 { 1, 4, 4, 3, 3, 4, 4 },
197 { 1, 4, 4, 3, 3, 4, 4 },
198 { 2, 3, 3, 4, 4, 3, 2 },
199 { 2, 3, 3, 3, 3, 2 },
200 }
201 };
202
203 static const uint8_t mv_syms[2][16][10] =
204 {
205 {
206 { 1, 8, 9, 4, 3, 2, 7, 5, 6, 0 },
207 { 0, 9, 5, 4, 2, 3, 8, 1 },
208 { 3, 9, 5, 0, 4, 8, 2, 1 },
209 { 1, 3, 4, 8, 5, 2, 0 },
210 { 0, 5, 4, 8, 2, 3, 9, 1 },
211 { 0, 3, 5, 9, 4, 8, 2, 1 },
212 { 0, 3, 9, 5, 8, 4, 2, 1 },
213 { 0, 2, 3, 4, 8, 5, 1 },
214 { 0, 3, 8, 4, 2, 5, 9, 1 },
215 { 2, 8, 9, 3, 5, 4, 0, 1 },
216 { 0, 4, 3, 8, 9, 5, 2, 1 },
217 { 0, 4, 8, 5, 3, 2, 1 },
218 { 1, 9, 4, 2, 0, 5, 3 },
219 { 2, 4, 9, 5, 3, 0, 1 },
220 { 0, 4, 9, 5, 3, 2, 1 },
221 { 5, 4, 1, 0, 3, 2 },
222 },
223 {
224 { 8, 2, 3, 6, 1, 7, 5, 4, 9, 0 },
225 { 9, 2, 3, 5, 4, 1, 8, 0 },
226 { 0, 5, 4, 2, 9, 3, 8, 1 },
227 { 1, 5, 4, 2, 8, 3, 0 },
228 { 2, 9, 8, 3, 5, 4, 0, 1 },
229 { 3, 5, 4, 2, 9, 8, 0, 1 },
230 { 1, 2, 0, 9, 8, 3, 5, 4 },
231 { 1, 8, 5, 2, 0, 4, 3 },
232 { 0, 5, 4, 2, 8, 3, 9, 1 },
233 { 1, 2, 0, 9, 8, 3, 5, 4 },
234 { 0, 3, 9, 8, 5, 4, 2, 1 },
235 { 0, 4, 3, 8, 5, 2, 1 },
236 { 1, 5, 4, 2, 0, 9, 3 },
237 { 1, 9, 5, 2, 0, 4, 3 },
238 { 0, 5, 3, 9, 4, 2, 1 },
239 { 0, 4, 5, 3, 2, 1 },
240 }
241 };
242
243 typedef struct BlockXY {
244 int w, h;
245 int ax, ay;
246 int x, y;
247 int size;
248 uint8_t *block;
249 int linesize;
250 } BlockXY;
251
252 typedef struct MotionXY {
253 int x, y;
254 } MotionXY;
255
256 typedef struct MobiClipContext {
257 AVFrame *pic[6];
258
259 int current_pic;
260 int moflex;
261 int dct_tab_idx;
262 int quantizer;
263
264 GetBitContext gb;
265
266 uint8_t *bitstream;
267 int bitstream_size;
268
269 int qtab[2][64];
270 uint8_t pre[32];
271 MotionXY *motion;
272 int motion_size;
273
274 BswapDSPContext bdsp;
275 } MobiClipContext;
276
277 static VLC rl_vlc[2];
278 static VLC mv_vlc[2][16];
279
280 ✗ static av_cold void mobiclip_init_static(void)
281 {
282 ✗ INIT_VLC_STATIC_FROM_LENGTHS(&rl_vlc[0], MOBI_RL_VLC_BITS, 104,
283 bits0, sizeof(*bits0),
284 syms0, sizeof(*syms0), sizeof(*syms0),
285 0, 0, 1 << MOBI_RL_VLC_BITS);
286 ✗ INIT_VLC_STATIC_FROM_LENGTHS(&rl_vlc[1], MOBI_RL_VLC_BITS, 104,
287 bits0, sizeof(*bits0),
288 syms1, sizeof(*syms1), sizeof(*syms1),
289 0, 0, 1 << MOBI_RL_VLC_BITS);
290 ✗ for (int i = 0; i < 2; i++) {
291 static VLCElem vlc_buf[2 * 16 << MOBI_MV_VLC_BITS];
292 ✗ for (int j = 0; j < 16; j++) {
293 ✗ mv_vlc[i][j].table = &vlc_buf[(16 * i + j) << MOBI_MV_VLC_BITS];
294 ✗ mv_vlc[i][j].table_allocated = 1 << MOBI_MV_VLC_BITS;
295 ✗ ff_init_vlc_from_lengths(&mv_vlc[i][j], MOBI_MV_VLC_BITS, mv_len[j],
296 ✗ mv_bits[i][j], sizeof(*mv_bits[i][j]),
297 ✗ mv_syms[i][j], sizeof(*mv_syms[i][j]), sizeof(*mv_syms[i][j]),
298 0, INIT_VLC_USE_NEW_STATIC, NULL);
299 }
300 }
301 }
302
303 ✗ static av_cold int mobiclip_init(AVCodecContext *avctx)
304 {
305 static AVOnce init_static_once = AV_ONCE_INIT;
306 ✗ MobiClipContext *s = avctx->priv_data;
307
308 ✗ if (avctx->width & 15 || avctx->height & 15) {
309 ✗ av_log(avctx, AV_LOG_ERROR, "width/height not multiple of 16\n");
310 ✗ return AVERROR_INVALIDDATA;
311 }
312
313 ✗ ff_bswapdsp_init(&s->bdsp);
314
315 ✗ avctx->pix_fmt = AV_PIX_FMT_YUV420P;
316
317 ✗ s->motion = av_calloc(avctx->width / 16 + 3, sizeof(MotionXY));
318 ✗ if (!s->motion)
319 ✗ return AVERROR(ENOMEM);
320 ✗ s->motion_size = (avctx->width / 16 + 3) * sizeof(MotionXY);
321
322 ✗ for (int i = 0; i < 6; i++) {
323 ✗ s->pic[i] = av_frame_alloc();
324 ✗ if (!s->pic[i])
325 ✗ return AVERROR(ENOMEM);
326 }
327
328 ✗ ff_thread_once(&init_static_once, mobiclip_init_static);
329
330 ✗ return 0;
331 }
332
333 ✗ static int setup_qtables(AVCodecContext *avctx, int quantizer)
334 {
335 ✗ MobiClipContext *s = avctx->priv_data;
336 int qx, qy;
337
338 ✗ if (quantizer < 12 || quantizer > 161)
339 ✗ return AVERROR_INVALIDDATA;
340
341 ✗ s->quantizer = quantizer;
342
343 ✗ qx = quantizer % 6;
344 ✗ qy = quantizer / 6;
345
346 ✗ for (int i = 0; i < 16; i++)
347 ✗ s->qtab[0][i] = quant4x4_tab[qx][i] << qy;
348
349 ✗ for (int i = 0; i < 64; i++)
350 ✗ s->qtab[1][i] = quant8x8_tab[qx][i] << (qy - 2);
351
352 ✗ for (int i = 0; i < 20; i++)
353 ✗ s->pre[i] = 9;
354
355 ✗ return 0;
356 }
357
358 ✗ static void inverse4(unsigned *rs)
359 {
360 ✗ unsigned a = rs[0] + rs[2];
361 ✗ unsigned b = rs[0] - rs[2];
362 ✗ unsigned c = rs[1] + ((int)rs[3] >> 1);
363 ✗ unsigned d = ((int)rs[1] >> 1) - rs[3];
364
365 ✗ rs[0] = a + c;
366 ✗ rs[1] = b + d;
367 ✗ rs[2] = b - d;
368 ✗ rs[3] = a - c;
369 }
370
371 ✗ static void idct(int *arr, int size)
372 {
373 int e, f, g, h;
374 unsigned x3, x2, x1, x0;
375 int tmp[4];
376
377 ✗ if (size == 4) {
378 ✗ inverse4(arr);
379 ✗ return;
380 }
381
382 ✗ tmp[0] = arr[0];
383 ✗ tmp[1] = arr[2];
384 ✗ tmp[2] = arr[4];
385 ✗ tmp[3] = arr[6];
386
387 ✗ inverse4(tmp);
388
389 ✗ e = (unsigned)arr[7] + arr[1] - arr[3] - (arr[3] >> 1);
390 ✗ f = (unsigned)arr[7] - arr[1] + arr[5] + (arr[5] >> 1);
391 ✗ g = (unsigned)arr[5] - arr[3] - arr[7] - (arr[7] >> 1);
392 ✗ h = (unsigned)arr[5] + arr[3] + arr[1] + (arr[1] >> 1);
393 ✗ x3 = (unsigned)g + (h >> 2);
394 ✗ x2 = (unsigned)e + (f >> 2);
395 ✗ x1 = (e >> 2) - (unsigned)f;
396 ✗ x0 = (unsigned)h - (g >> 2);
397
398 ✗ arr[0] = tmp[0] + x0;
399 ✗ arr[1] = tmp[1] + x1;
400 ✗ arr[2] = tmp[2] + x2;
401 ✗ arr[3] = tmp[3] + x3;
402 ✗ arr[4] = tmp[3] - x3;
403 ✗ arr[5] = tmp[2] - x2;
404 ✗ arr[6] = tmp[1] - x1;
405 ✗ arr[7] = tmp[0] - x0;
406 }
407
408 ✗ static void read_run_encoding(AVCodecContext *avctx,
409 int *last, int *run, int *level)
410 {
411 ✗ MobiClipContext *s = avctx->priv_data;
412 ✗ GetBitContext *gb = &s->gb;
413 ✗ int n = get_vlc2(gb, rl_vlc[s->dct_tab_idx].table,
414 MOBI_RL_VLC_BITS, 1);
415
416 ✗ *last = (n >> 11) == 1;
417 ✗ *run = (n >> 5) & 0x3F;
418 ✗ *level = n & 0x1F;
419 }
420
421 ✗ static int add_coefficients(AVCodecContext *avctx, AVFrame *frame,
422 int bx, int by, int size, int plane)
423 {
424 ✗ MobiClipContext *s = avctx->priv_data;
425 ✗ GetBitContext *gb = &s->gb;
426 ✗ int mat[64] = { 0 };
427 ✗ const uint8_t *ztab = size == 8 ? ff_zigzag_direct : zigzag4x4_tab;
428 ✗ const int *qtab = s->qtab[size == 8];
429 ✗ uint8_t *dst = frame->data[plane] + by * frame->linesize[plane] + bx;
430
431 ✗ for (int pos = 0; get_bits_left(gb) > 0; pos++) {
432 int qval, last, run, level;
433
434 ✗ read_run_encoding(avctx, &last, &run, &level);
435
436 ✗ if (level) {
437 ✗ if (get_bits1(gb))
438 ✗ level = -level;
439 ✗ } else if (!get_bits1(gb)) {
440 ✗ read_run_encoding(avctx, &last, &run, &level);
441 ✗ level += run_residue[s->dct_tab_idx][(last ? 64 : 0) + run];
442 ✗ if (get_bits1(gb))
443 ✗ level = -level;
444 ✗ } else if (!get_bits1(gb)) {
445 ✗ read_run_encoding(avctx, &last, &run, &level);
446 ✗ run += run_residue[s->dct_tab_idx][128 + (last ? 64 : 0) + level];
447 ✗ if (get_bits1(gb))
448 ✗ level = -level;
449 } else {
450 ✗ last = get_bits1(gb);
451 ✗ run = get_bits(gb, 6);
452 ✗ level = get_sbits(gb, 12);
453 }
454
455 ✗ pos += run;
456 ✗ if (pos >= size * size)
457 ✗ return AVERROR_INVALIDDATA;
458 ✗ qval = qtab[pos];
459 ✗ mat[ztab[pos]] = qval *(unsigned)level;
460
461 ✗ if (last)
462 ✗ break;
463 }
464
465 ✗ mat[0] += 32;
466 ✗ for (int y = 0; y < size; y++)
467 ✗ idct(&mat[y * size], size);
468
469 ✗ for (int y = 0; y < size; y++) {
470 ✗ for (int x = y + 1; x < size; x++) {
471 ✗ int a = mat[x * size + y];
472 ✗ int b = mat[y * size + x];
473
474 ✗ mat[y * size + x] = a;
475 ✗ mat[x * size + y] = b;
476 }
477
478 ✗ idct(&mat[y * size], size);
479 ✗ for (int x = 0; x < size; x++)
480 ✗ dst[x] = av_clip_uint8(dst[x] + (mat[y * size + x] >> 6));
481 ✗ dst += frame->linesize[plane];
482 }
483
484 ✗ return 0;
485 }
486
487 ✗ static int add_pframe_coefficients(AVCodecContext *avctx, AVFrame *frame,
488 int bx, int by, int size, int plane)
489 {
490 ✗ MobiClipContext *s = avctx->priv_data;
491 ✗ GetBitContext *gb = &s->gb;
492 ✗ int ret, idx = get_ue_golomb_31(gb);
493
494 ✗ if (idx == 0) {
495 ✗ return add_coefficients(avctx, frame, bx, by, size, plane);
496 ✗ } else if ((unsigned)idx < FF_ARRAY_ELEMS(pframe_block4x4_coefficients_tab)) {
497 ✗ int flags = pframe_block4x4_coefficients_tab[idx];
498
499 ✗ for (int y = by; y < by + 8; y += 4) {
500 ✗ for (int x = bx; x < bx + 8; x += 4) {
501 ✗ if (flags & 1) {
502 ✗ ret = add_coefficients(avctx, frame, x, y, 4, plane);
503 ✗ if (ret < 0)
504 ✗ return ret;
505 }
506 ✗ flags >>= 1;
507 }
508 }
509 ✗ return 0;
510 } else {
511 ✗ return AVERROR_INVALIDDATA;
512 }
513 }
514
515 ✗ static int adjust(int x, int size)
516 {
517 ✗ return size == 16 ? (x + 1) >> 1 : x;
518 }
519
520 ✗ static uint8_t pget(BlockXY b)
521 {
522 ✗ BlockXY ret = b;
523 int x, y;
524
525 ✗ if (b.x == -1 && b.y >= b.size) {
526 ✗ ret.x = -1, ret.y = b.size - 1;
527 ✗ } else if (b.x >= -1 && b.y >= -1) {
528 ✗ ret.x = b.x, ret.y = b.y;
529 ✗ } else if (b.x == -1 && b.y == -2) {
530 ✗ ret.x = 0, ret.y = -1;
531 ✗ } else if (b.x == -2 && b.y == -1) {
532 ✗ ret.x = -1, ret.y = 0;
533 }
534
535 ✗ y = av_clip(ret.ay + ret.y, 0, ret.h - 1);
536 ✗ x = av_clip(ret.ax + ret.x, 0, ret.w - 1);
537
538 ✗ return ret.block[y * ret.linesize + x];
539 }
540
541 ✗ static uint8_t half(int a, int b)
542 {
543 ✗ return ((a + b) + 1) / 2;
544 }
545
546 ✗ static uint8_t half3(int a, int b, int c)
547 {
548 ✗ return ((a + b + b + c) * 2 / 4 + 1) / 2;
549 }
550
551 ✗ static uint8_t pick_above(BlockXY bxy)
552 {
553 ✗ bxy.y = bxy.y - 1;
554
555 ✗ return pget(bxy);
556 }
557
558 ✗ static uint8_t pick_left(BlockXY bxy)
559 {
560 ✗ bxy.x = bxy.x - 1;
561
562 ✗ return pget(bxy);
563 }
564
565 ✗ static uint8_t half_horz(BlockXY bxy)
566 {
567 ✗ BlockXY a = bxy, b = bxy, c = bxy;
568
569 ✗ a.x -= 1;
570 ✗ c.x += 1;
571
572 ✗ return half3(pget(a), pget(b), pget(c));
573 }
574
575 ✗ static uint8_t half_vert(BlockXY bxy)
576 {
577 ✗ BlockXY a = bxy, b = bxy, c = bxy;
578
579 ✗ a.y -= 1;
580 ✗ c.y += 1;
581
582 ✗ return half3(pget(a), pget(b), pget(c));
583 }
584
585 ✗ static uint8_t pick_4(BlockXY bxy)
586 {
587 int val;
588
589 ✗ if ((bxy.x % 2) == 0) {
590 BlockXY ba, bb;
591 int a, b;
592
593 ✗ ba = bxy;
594 ✗ ba.x = -1;
595 ✗ ba.y = bxy.y + bxy.x / 2;
596 ✗ a = pget(ba);
597
598 ✗ bb = bxy;
599 ✗ bb.x = -1;
600 ✗ bb.y = bxy.y + bxy.x / 2 + 1;
601 ✗ b = pget(bb);
602
603 ✗ val = half(a, b);
604 } else {
605 BlockXY ba;
606
607 ✗ ba = bxy;
608 ✗ ba.x = -1;
609 ✗ ba.y = bxy.y + bxy.x / 2 + 1;
610 ✗ val = half_vert(ba);
611 }
612
613 ✗ return val;
614 }
615
616 ✗ static uint8_t pick_5(BlockXY bxy)
617 {
618 int val;
619
620 ✗ if (bxy.x == 0) {
621 ✗ BlockXY a = bxy;
622 ✗ BlockXY b = bxy;
623
624 ✗ a.x = -1;
625 ✗ a.y -= 1;
626
627 ✗ b.x = -1;
628
629 ✗ val = half(pget(a), pget(b));
630 ✗ } else if (bxy.y == 0) {
631 ✗ BlockXY a = bxy;
632
633 ✗ a.x -= 2;
634 ✗ a.y -= 1;
635
636 ✗ val = half_horz(a);
637 ✗ } else if (bxy.x == 1) {
638 ✗ BlockXY a = bxy;
639
640 ✗ a.x -= 2;
641 ✗ a.y -= 1;
642
643 ✗ val = half_vert(a);
644 } else {
645 ✗ BlockXY a = bxy;
646
647 ✗ a.x -= 2;
648 ✗ a.y -= 1;
649
650 ✗ val = pget(a);
651 }
652
653 ✗ return val;
654 }
655
656 ✗ static uint8_t pick_6(BlockXY bxy)
657 {
658 int val;
659
660 ✗ if (bxy.y == 0) {
661 ✗ BlockXY a = bxy;
662 ✗ BlockXY b = bxy;
663
664 ✗ a.x -= 1;
665 ✗ a.y = -1;
666
667 ✗ b.y = -1;
668
669 ✗ val = half(pget(a), pget(b));
670 ✗ } else if (bxy.x == 0) {
671 ✗ BlockXY a = bxy;
672
673 ✗ a.x -= 1;
674 ✗ a.y -= 2;
675
676 ✗ val = half_vert(a);
677 ✗ } else if (bxy.y == 1) {
678 ✗ BlockXY a = bxy;
679
680 ✗ a.x -= 1;
681 ✗ a.y -= 2;
682
683 ✗ val = half_horz(a);
684 } else {
685 ✗ BlockXY a = bxy;
686
687 ✗ a.x -= 1;
688 ✗ a.y -= 2;
689
690 ✗ val = pget(a);
691 }
692
693 ✗ return val;
694 }
695
696 ✗ static uint8_t pick_7(BlockXY bxy)
697 {
698 int clr, acc1, acc2;
699 ✗ BlockXY a = bxy;
700
701 ✗ a.x -= 1;
702 ✗ a.y -= 1;
703 ✗ clr = pget(a);
704 ✗ if (bxy.x && bxy.y)
705 ✗ return clr;
706
707 ✗ if (bxy.x == 0) {
708 ✗ a.x = -1;
709 ✗ a.y = bxy.y;
710 } else {
711 ✗ a.x = bxy.x - 2;
712 ✗ a.y = -1;
713 }
714 ✗ acc1 = pget(a);
715
716 ✗ if (bxy.y == 0) {
717 ✗ a.x = bxy.x;
718 ✗ a.y = -1;
719 } else {
720 ✗ a.x = -1;
721 ✗ a.y = bxy.y - 2;
722 }
723 ✗ acc2 = pget(a);
724
725 ✗ return half3(acc1, clr, acc2);
726 }
727
728 ✗ static uint8_t pick_8(BlockXY bxy)
729 {
730 ✗ BlockXY ba = bxy;
731 ✗ BlockXY bb = bxy;
732 int val;
733
734 ✗ if (bxy.y == 0) {
735 int a, b;
736
737 ✗ ba.y = -1;
738 ✗ a = pget(ba);
739
740 ✗ bb.x += 1;
741 ✗ bb.y = -1;
742
743 ✗ b = pget(bb);
744
745 ✗ val = half(a, b);
746 ✗ } else if (bxy.y == 1) {
747 ✗ ba.x += 1;
748 ✗ ba.y -= 2;
749
750 ✗ val = half_horz(ba);
751 ✗ } else if (bxy.x < bxy.size - 1) {
752 ✗ ba.x += 1;
753 ✗ ba.y -= 2;
754
755 ✗ val = pget(ba);
756 ✗ } else if (bxy.y % 2 == 0) {
757 int a, b;
758
759 ✗ ba.x = bxy.y / 2 + bxy.size - 1;
760 ✗ ba.y = -1;
761 ✗ a = pget(ba);
762
763 ✗ bb.x = bxy.y / 2 + bxy.size;
764 ✗ bb.y = -1;
765
766 ✗ b = pget(bb);
767
768 ✗ val = half(a, b);
769 } else {
770 ✗ ba.x = bxy.y / 2 + bxy.size;
771 ✗ ba.y = -1;
772
773 ✗ val = half_horz(ba);
774 }
775
776 ✗ return val;
777 }
778
779 ✗ static void block_fill_simple(uint8_t *block, int size, int linesize, int fill)
780 {
781 ✗ for (int y = 0; y < size; y++) {
782 ✗ memset(block, fill, size);
783 ✗ block += linesize;
784 }
785 }
786
787 ✗ static void block_fill(uint8_t *block, int size, int linesize,
788 int w, int h, int ax, int ay,
789 uint8_t (*pick)(BlockXY bxy))
790 {
791 BlockXY bxy;
792
793 ✗ bxy.size = size;
794 ✗ bxy.block = block;
795 ✗ bxy.linesize = linesize;
796 ✗ bxy.w = w;
797 ✗ bxy.h = h;
798 ✗ bxy.ay = ay;
799 ✗ bxy.ax = ax;
800
801 ✗ for (int y = 0; y < size; y++) {
802 ✗ bxy.y = y;
803 ✗ for (int x = 0; x < size; x++) {
804 uint8_t val;
805
806 ✗ bxy.x = x;
807
808 ✗ val = pick(bxy);
809
810 ✗ block[ax + x + (ay + y) * linesize] = val;
811 }
812 }
813 }
814
815 ✗ static int block_sum(const uint8_t *block, int w, int h, int linesize)
816 {
817 ✗ int sum = 0;
818
819 ✗ for (int y = 0; y < h; y++) {
820 ✗ for (int x = 0; x < w; x++) {
821 ✗ sum += block[x];
822 }
823 ✗ block += linesize;
824 }
825
826 ✗ return sum;
827 }
828
829 ✗ static int predict_intra(AVCodecContext *avctx, AVFrame *frame, int ax, int ay,
830 int pmode, int add_coeffs, int size, int plane)
831 {
832 ✗ MobiClipContext *s = avctx->priv_data;
833 ✗ GetBitContext *gb = &s->gb;
834 ✗ int w = avctx->width >> !!plane, h = avctx->height >> !!plane;
835 ✗ int ret = 0;
836
837 ✗ switch (pmode) {
838 ✗ case 0:
839 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_above);
840 ✗ break;
841 ✗ case 1:
842 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_left);
843 ✗ break;
844 ✗ case 2:
845 {
846 int arr1[16];
847 int arr2[16];
848 ✗ uint8_t *top = frame->data[plane] + FFMAX(ay - 1, 0) * frame->linesize[plane] + ax;
849 ✗ uint8_t *left = frame->data[plane] + ay * frame->linesize[plane] + FFMAX(ax - 1, 0);
850 ✗ int bottommost = frame->data[plane][(ay + size - 1) * frame->linesize[plane] + FFMAX(ax - 1, 0)];
851 ✗ int rightmost = frame->data[plane][FFMAX(ay - 1, 0) * frame->linesize[plane] + ax + size - 1];
852 ✗ int avg = (bottommost + rightmost + 1) / 2 + 2 * av_clip(get_se_golomb(gb), -(1<<16), 1<<16);
853 ✗ int r6 = adjust(avg - bottommost, size);
854 ✗ int r9 = adjust(avg - rightmost, size);
855 ✗ int shift = adjust(size, size) == 8 ? 3 : 2;
856 uint8_t *block;
857
858 ✗ for (int x = 0; x < size; x++) {
859 ✗ int val = top[x];
860 ✗ arr1[x] = adjust(((bottommost - val) * (1 << shift)) + r6 * (x + 1), size);
861 }
862
863 ✗ for (int y = 0; y < size; y++) {
864 ✗ int val = left[y * frame->linesize[plane]];
865 ✗ arr2[y] = adjust(((rightmost - val) * (1 << shift)) + r9 * (y + 1), size);
866 }
867
868 ✗ block = frame->data[plane] + ay * frame->linesize[plane] + ax;
869 ✗ for (int y = 0; y < size; y++) {
870 ✗ for (int x = 0; x < size; x++) {
871 ✗ block[x] = (((top[x] + left[0] + ((arr1[x] * (y + 1) +
872 ✗ arr2[y] * (x + 1)) >> 2 * shift)) + 1) / 2) & 0xFF;
873 }
874 ✗ block += frame->linesize[plane];
875 ✗ left += frame->linesize[plane];
876 }
877 }
878 ✗ break;
879 ✗ case 3:
880 {
881 uint8_t fill;
882
883 ✗ if (ax == 0 && ay == 0) {
884 ✗ fill = 0x80;
885 ✗ } else if (ax >= 1 && ay >= 1) {
886 ✗ int left = block_sum(frame->data[plane] + ay * frame->linesize[plane] + ax - 1,
887 1, size, frame->linesize[plane]);
888 ✗ int top = block_sum(frame->data[plane] + (ay - 1) * frame->linesize[plane] + ax,
889 size, 1, frame->linesize[plane]);
890
891 ✗ fill = ((left + top) * 2 / (2 * size) + 1) / 2;
892 ✗ } else if (ax >= 1) {
893 ✗ fill = (block_sum(frame->data[plane] + ay * frame->linesize[plane] + ax - 1,
894 ✗ 1, size, frame->linesize[plane]) * 2 / size + 1) / 2;
895 ✗ } else if (ay >= 1) {
896 ✗ fill = (block_sum(frame->data[plane] + (ay - 1) * frame->linesize[plane] + ax,
897 ✗ size, 1, frame->linesize[plane]) * 2 / size + 1) / 2;
898 } else {
899 ✗ return -1;
900 }
901
902 ✗ block_fill_simple(frame->data[plane] + ay * frame->linesize[plane] + ax,
903 size, frame->linesize[plane], fill);
904 }
905 ✗ break;
906 ✗ case 4:
907 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_4);
908 ✗ break;
909 ✗ case 5:
910 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_5);
911 ✗ break;
912 ✗ case 6:
913 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_6);
914 ✗ break;
915 ✗ case 7:
916 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_7);
917 ✗ break;
918 ✗ case 8:
919 ✗ block_fill(frame->data[plane], size, frame->linesize[plane], w, h, ax, ay, pick_8);
920 ✗ break;
921 }
922
923 ✗ if (add_coeffs)
924 ✗ ret = add_coefficients(avctx, frame, ax, ay, size, plane);
925
926 ✗ return ret;
927 }
928
929 ✗ static int get_prediction(AVCodecContext *avctx, int x, int y, int size)
930 {
931 ✗ MobiClipContext *s = avctx->priv_data;
932 ✗ GetBitContext *gb = &s->gb;
933 ✗ int index = (y & 0xC) | (x / 4 % 4);
934
935 ✗ uint8_t val = FFMIN(s->pre[index], index % 4 == 0 ? 9 : s->pre[index + 3]);
936 ✗ if (val == 9)
937 ✗ val = 3;
938
939 ✗ if (!get_bits1(gb)) {
940 ✗ int x = get_bits(gb, 3);
941 ✗ val = x + (x >= val ? 1 : 0);
942 }
943
944 ✗ s->pre[index + 4] = val;
945 ✗ if (size == 8)
946 ✗ s->pre[index + 5] = s->pre[index + 8] = s->pre[index + 9] = val;
947
948 ✗ return val;
949 }
950
951 ✗ static int process_block(AVCodecContext *avctx, AVFrame *frame,
952 int x, int y, int pmode, int has_coeffs, int plane)
953 {
954 ✗ MobiClipContext *s = avctx->priv_data;
955 ✗ GetBitContext *gb = &s->gb;
956 int tmp, ret;
957
958 ✗ if (!has_coeffs) {
959 ✗ if (pmode < 0)
960 ✗ pmode = get_prediction(avctx, x, y, 8);
961 ✗ return predict_intra(avctx, frame, x, y, pmode, 0, 8, plane);
962 }
963
964 ✗ tmp = get_ue_golomb_31(gb);
965 ✗ if ((unsigned)tmp > FF_ARRAY_ELEMS(block4x4_coefficients_tab))
966 ✗ return AVERROR_INVALIDDATA;
967
968 ✗ if (tmp == 0) {
969 ✗ if (pmode < 0)
970 ✗ pmode = get_prediction(avctx, x, y, 8);
971 ✗ ret = predict_intra(avctx, frame, x, y, pmode, 1, 8, plane);
972 } else {
973 ✗ int flags = block4x4_coefficients_tab[tmp - 1];
974
975 ✗ for (int by = y; by < y + 8; by += 4) {
976 ✗ for (int bx = x; bx < x + 8; bx += 4) {
977 ✗ int new_pmode = pmode;
978
979 ✗ if (new_pmode < 0)
980 ✗ new_pmode = get_prediction(avctx, bx, by, 4);
981 ✗ ret = predict_intra(avctx, frame, bx, by, new_pmode, flags & 1, 4, plane);
982 ✗ if (ret < 0)
983 ✗ return ret;
984 ✗ flags >>= 1;
985 }
986 }
987 }
988
989 ✗ return ret;
990 }
991
992 ✗ static int decode_macroblock(AVCodecContext *avctx, AVFrame *frame,
993 int x, int y, int predict)
994 {
995 ✗ MobiClipContext *s = avctx->priv_data;
996 ✗ GetBitContext *gb = &s->gb;
997 ✗ int flags, pmode_uv, idx = get_ue_golomb(gb);
998 ✗ int ret = 0;
999
1000 ✗ if (idx < 0 || idx >= FF_ARRAY_ELEMS(block8x8_coefficients_tab))
1001 ✗ return AVERROR_INVALIDDATA;
1002
1003 ✗ flags = block8x8_coefficients_tab[idx];
1004
1005 ✗ if (predict) {
1006 ✗ ret = process_block(avctx, frame, x, y, -1, flags & 1, 0);
1007 ✗ if (ret < 0)
1008 ✗ return ret;
1009 ✗ flags >>= 1;
1010 ✗ ret = process_block(avctx, frame, x + 8, y, -1, flags & 1, 0);
1011 ✗ if (ret < 0)
1012 ✗ return ret;
1013 ✗ flags >>= 1;
1014 ✗ ret = process_block(avctx, frame, x, y + 8, -1, flags & 1, 0);
1015 ✗ if (ret < 0)
1016 ✗ return ret;
1017 ✗ flags >>= 1;
1018 ✗ ret = process_block(avctx, frame, x + 8, y + 8, -1, flags & 1, 0);
1019 ✗ if (ret < 0)
1020 ✗ return ret;
1021 ✗ flags >>= 1;
1022 } else {
1023 ✗ int pmode = get_bits(gb, 3);
1024
1025 ✗ if (pmode == 2) {
1026 ✗ ret = predict_intra(avctx, frame, x, y, pmode, 0, 16, 0);
1027 ✗ if (ret < 0)
1028 ✗ return ret;
1029 ✗ pmode = 9;
1030 }
1031
1032 ✗ ret = process_block(avctx, frame, x, y, pmode, flags & 1, 0);
1033 ✗ if (ret < 0)
1034 ✗ return ret;
1035 ✗ flags >>= 1;
1036 ✗ ret = process_block(avctx, frame, x + 8, y, pmode, flags & 1, 0);
1037 ✗ if (ret < 0)
1038 ✗ return ret;
1039 ✗ flags >>= 1;
1040 ✗ ret = process_block(avctx, frame, x, y + 8, pmode, flags & 1, 0);
1041 ✗ if (ret < 0)
1042 ✗ return ret;
1043 ✗ flags >>= 1;
1044 ✗ ret = process_block(avctx, frame, x + 8, y + 8, pmode, flags & 1, 0);
1045 ✗ if (ret < 0)
1046 ✗ return ret;
1047 ✗ flags >>= 1;
1048 }
1049
1050 ✗ pmode_uv = get_bits(gb, 3);
1051 ✗ if (pmode_uv == 2) {
1052 ✗ ret = predict_intra(avctx, frame, x >> 1, y >> 1, pmode_uv, 0, 8, 1 + !s->moflex);
1053 ✗ if (ret < 0)
1054 ✗ return ret;
1055 ✗ ret = predict_intra(avctx, frame, x >> 1, y >> 1, pmode_uv, 0, 8, 2 - !s->moflex);
1056 ✗ if (ret < 0)
1057 ✗ return ret;
1058 ✗ pmode_uv = 9;
1059 }
1060
1061 ✗ ret = process_block(avctx, frame, x >> 1, y >> 1, pmode_uv, flags & 1, 1 + !s->moflex);
1062 ✗ if (ret < 0)
1063 ✗ return ret;
1064 ✗ flags >>= 1;
1065 ✗ ret = process_block(avctx, frame, x >> 1, y >> 1, pmode_uv, flags & 1, 2 - !s->moflex);
1066 ✗ if (ret < 0)
1067 ✗ return ret;
1068
1069 ✗ return 0;
1070 }
1071
1072 ✗ static int get_index(int x)
1073 {
1074 ✗ return x == 16 ? 0 : x == 8 ? 1 : x == 4 ? 2 : x == 2 ? 3 : 0;
1075 }
1076
1077 ✗ static int predict_motion(AVCodecContext *avctx,
1078 int width, int height, int index,
1079 int offsetm, int offsetx, int offsety)
1080 {
1081 ✗ MobiClipContext *s = avctx->priv_data;
1082 ✗ MotionXY *motion = s->motion;
1083 ✗ GetBitContext *gb = &s->gb;
1084 ✗ int fheight = avctx->height;
1085 ✗ int fwidth = avctx->width;
1086
1087 ✗ if (index <= 5) {
1088 ✗ int sidx = -FFMAX(1, index) + s->current_pic;
1089 ✗ MotionXY mv = s->motion[0];
1090
1091 ✗ if (sidx < 0)
1092 ✗ sidx += 6;
1093
1094 ✗ if (index > 0) {
1095 ✗ mv.x = mv.x + (unsigned)get_se_golomb(gb);
1096 ✗ mv.y = mv.y + (unsigned)get_se_golomb(gb);
1097 }
1098 ✗ if (mv.x >= INT_MAX || mv.y >= INT_MAX)
1099 ✗ return AVERROR_INVALIDDATA;
1100
1101 ✗ motion[offsetm].x = mv.x;
1102 ✗ motion[offsetm].y = mv.y;
1103
1104 ✗ for (int i = 0; i < 3; i++) {
1105 int method, src_linesize, dst_linesize;
1106 uint8_t *src, *dst;
1107
1108 ✗ if (i == 1) {
1109 ✗ offsetx = offsetx >> 1;
1110 ✗ offsety = offsety >> 1;
1111 ✗ mv.x = mv.x >> 1;
1112 ✗ mv.y = mv.y >> 1;
1113 ✗ width = width >> 1;
1114 ✗ height = height >> 1;
1115 ✗ fwidth = fwidth >> 1;
1116 ✗ fheight = fheight >> 1;
1117 }
1118
1119 ✗ av_assert0(s->pic[sidx]);
1120 ✗ av_assert0(s->pic[s->current_pic]);
1121 ✗ av_assert0(s->pic[s->current_pic]->data[i]);
1122 ✗ if (!s->pic[sidx]->data[i])
1123 ✗ return AVERROR_INVALIDDATA;
1124
1125 ✗ method = (mv.x & 1) | ((mv.y & 1) << 1);
1126 ✗ src_linesize = s->pic[sidx]->linesize[i];
1127 ✗ dst_linesize = s->pic[s->current_pic]->linesize[i];
1128 ✗ dst = s->pic[s->current_pic]->data[i] + offsetx + offsety * dst_linesize;
1129
1130 ✗ if (offsetx + (mv.x >> 1) < 0 ||
1131 ✗ offsety + (mv.y >> 1) < 0 ||
1132 ✗ offsetx + width + (mv.x + 1 >> 1) > fwidth ||
1133 ✗ offsety + height + (mv.y + 1 >> 1) > fheight)
1134 ✗ return AVERROR_INVALIDDATA;
1135
1136 ✗ switch (method) {
1137 ✗ case 0:
1138 ✗ src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +
1139 ✗ (offsety + (mv.y >> 1)) * src_linesize;
1140 ✗ for (int y = 0; y < height; y++) {
1141 ✗ for (int x = 0; x < width; x++)
1142 ✗ dst[x] = src[x];
1143 ✗ dst += dst_linesize;
1144 ✗ src += src_linesize;
1145 }
1146 ✗ break;
1147 ✗ case 1:
1148 ✗ src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +
1149 ✗ (offsety + (mv.y >> 1)) * src_linesize;
1150 ✗ for (int y = 0; y < height; y++) {
1151 ✗ for (int x = 0; x < width; x++) {
1152 ✗ dst[x] = (uint8_t)((src[x] >> 1) + (src[x + 1] >> 1));
1153 }
1154
1155 ✗ dst += dst_linesize;
1156 ✗ src += src_linesize;
1157 }
1158 ✗ break;
1159 ✗ case 2:
1160 ✗ src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +
1161 ✗ (offsety + (mv.y >> 1)) * src_linesize;
1162 ✗ for (int y = 0; y < height; y++) {
1163 ✗ for (int x = 0; x < width; x++) {
1164 ✗ dst[x] = (uint8_t)((src[x] >> 1) + (src[x + src_linesize] >> 1));
1165 }
1166
1167 ✗ dst += dst_linesize;
1168 ✗ src += src_linesize;
1169 }
1170 ✗ break;
1171 ✗ case 3:
1172 ✗ src = s->pic[sidx]->data[i] + offsetx + (mv.x >> 1) +
1173 ✗ (offsety + (mv.y >> 1)) * src_linesize;
1174 ✗ for (int y = 0; y < height; y++) {
1175 ✗ for (int x = 0; x < width; x++) {
1176 ✗ dst[x] = (uint8_t)((((src[x] >> 1) + (src[x + 1] >> 1)) >> 1) +
1177 ✗ (((src[x + src_linesize] >> 1) + (src[x + 1 + src_linesize] >> 1)) >> 1));
1178 }
1179
1180 ✗ dst += dst_linesize;
1181 ✗ src += src_linesize;
1182 }
1183 ✗ break;
1184 }
1185 }
1186 } else {
1187 int tidx;
1188 ✗ int adjx = index == 8 ? 0 : width / 2;
1189 ✗ int adjy = index == 8 ? height / 2 : 0;
1190
1191 ✗ width = width - adjx;
1192 ✗ height = height - adjy;
1193 ✗ tidx = get_index(height) * 4 + get_index(width);
1194
1195 ✗ for (int i = 0; i < 2; i++) {
1196 int ret, idx2;
1197
1198 ✗ idx2 = get_vlc2(gb, mv_vlc[s->moflex][tidx].table,
1199 MOBI_MV_VLC_BITS, 1);
1200
1201 ✗ ret = predict_motion(avctx, width, height, idx2,
1202 ✗ offsetm, offsetx + i * adjx, offsety + i * adjy);
1203 ✗ if (ret < 0)
1204 ✗ return ret;
1205 }
1206 }
1207
1208 ✗ return 0;
1209 }
1210
1211 ✗ static int mobiclip_decode(AVCodecContext *avctx, AVFrame *rframe,
1212 int *got_frame, AVPacket *pkt)
1213 {
1214 ✗ MobiClipContext *s = avctx->priv_data;
1215 ✗ GetBitContext *gb = &s->gb;
1216 ✗ AVFrame *frame = s->pic[s->current_pic];
1217 int ret;
1218
1219 ✗ av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
1220 ✗ pkt->size);
1221
1222 ✗ if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)
1223 ✗ return ret;
1224
1225 ✗ s->bdsp.bswap16_buf((uint16_t *)s->bitstream,
1226 ✗ (uint16_t *)pkt->data,
1227 ✗ (pkt->size + 1) >> 1);
1228
1229 ✗ ret = init_get_bits8(gb, s->bitstream, FFALIGN(pkt->size, 2));
1230 ✗ if (ret < 0)
1231 ✗ return ret;
1232
1233 ✗ if (get_bits1(gb)) {
1234 ✗ frame->pict_type = AV_PICTURE_TYPE_I;
1235 ✗ frame->key_frame = 1;
1236 ✗ s->moflex = get_bits1(gb);
1237 ✗ s->dct_tab_idx = get_bits1(gb);
1238
1239 ✗ ret = setup_qtables(avctx, get_bits(gb, 6));
1240 ✗ if (ret < 0)
1241 ✗ return ret;
1242
1243 ✗ for (int y = 0; y < avctx->height; y += 16) {
1244 ✗ for (int x = 0; x < avctx->width; x += 16) {
1245 ✗ ret = decode_macroblock(avctx, frame, x, y, get_bits1(gb));
1246 ✗ if (ret < 0)
1247 ✗ return ret;
1248 }
1249 }
1250 } else {
1251 ✗ MotionXY *motion = s->motion;
1252
1253 ✗ memset(motion, 0, s->motion_size);
1254
1255 ✗ frame->pict_type = AV_PICTURE_TYPE_P;
1256 ✗ frame->key_frame = 0;
1257 ✗ s->dct_tab_idx = 0;
1258
1259 ✗ ret = setup_qtables(avctx, s->quantizer + get_se_golomb(gb));
1260 ✗ if (ret < 0)
1261 ✗ return ret;
1262
1263 ✗ for (int y = 0; y < avctx->height; y += 16) {
1264 ✗ for (int x = 0; x < avctx->width; x += 16) {
1265 int idx;
1266
1267 ✗ motion[0].x = mid_pred(motion[x / 16 + 1].x, motion[x / 16 + 2].x, motion[x / 16 + 3].x);
1268 ✗ motion[0].y = mid_pred(motion[x / 16 + 1].y, motion[x / 16 + 2].y, motion[x / 16 + 3].y);
1269 ✗ motion[x / 16 + 2].x = 0;
1270 ✗ motion[x / 16 + 2].y = 0;
1271
1272 ✗ idx = get_vlc2(gb, mv_vlc[s->moflex][0].table,
1273 MOBI_MV_VLC_BITS, 1);
1274
1275 ✗ if (idx == 6 || idx == 7) {
1276 ✗ ret = decode_macroblock(avctx, frame, x, y, idx == 7);
1277 ✗ if (ret < 0)
1278 ✗ return ret;
1279 } else {
1280 int flags, idx2;
1281 ✗ ret = predict_motion(avctx, 16, 16, idx, x / 16 + 2, x, y);
1282 ✗ if (ret < 0)
1283 ✗ return ret;
1284 ✗ idx2 = get_ue_golomb(gb);
1285 ✗ if (idx2 >= FF_ARRAY_ELEMS(pframe_block8x8_coefficients_tab))
1286 ✗ return AVERROR_INVALIDDATA;
1287 ✗ flags = pframe_block8x8_coefficients_tab[idx2];
1288
1289 ✗ for (int sy = y; sy < y + 16; sy += 8) {
1290 ✗ for (int sx = x; sx < x + 16; sx += 8) {
1291 ✗ if (flags & 1)
1292 ✗ add_pframe_coefficients(avctx, frame, sx, sy, 8, 0);
1293 ✗ flags >>= 1;
1294 }
1295 }
1296
1297 ✗ if (flags & 1)
1298 ✗ add_pframe_coefficients(avctx, frame, x >> 1, y >> 1, 8, 1 + !s->moflex);
1299 ✗ flags >>= 1;
1300 ✗ if (flags & 1)
1301 ✗ add_pframe_coefficients(avctx, frame, x >> 1, y >> 1, 8, 2 - !s->moflex);
1302 }
1303 }
1304 }
1305 }
1306
1307 ✗ if (!s->moflex)
1308 ✗ avctx->colorspace = AVCOL_SPC_YCGCO;
1309
1310 ✗ s->current_pic = (s->current_pic + 1) % 6;
1311 ✗ ret = av_frame_ref(rframe, frame);
1312 ✗ if (ret < 0)
1313 ✗ return ret;
1314 ✗ *got_frame = 1;
1315
1316 ✗ return 0;
1317 }
1318
1319 ✗ static void mobiclip_flush(AVCodecContext *avctx)
1320 {
1321 ✗ MobiClipContext *s = avctx->priv_data;
1322
1323 ✗ for (int i = 0; i < 6; i++)
1324 ✗ av_frame_unref(s->pic[i]);
1325 }
1326
1327 ✗ static av_cold int mobiclip_close(AVCodecContext *avctx)
1328 {
1329 ✗ MobiClipContext *s = avctx->priv_data;
1330
1331 ✗ av_freep(&s->bitstream);
1332 ✗ s->bitstream_size = 0;
1333 ✗ av_freep(&s->motion);
1334 ✗ s->motion_size = 0;
1335
1336 ✗ for (int i = 0; i < 6; i++) {
1337 ✗ av_frame_free(&s->pic[i]);
1338 }
1339
1340 ✗ return 0;
1341 }
1342
1343 const FFCodec ff_mobiclip_decoder = {
1344 .p.name = "mobiclip",
1345 .p.long_name = NULL_IF_CONFIG_SMALL("MobiClip Video"),
1346 .p.type = AVMEDIA_TYPE_VIDEO,
1347 .p.id = AV_CODEC_ID_MOBICLIP,
1348 .priv_data_size = sizeof(MobiClipContext),
1349 .init = mobiclip_init,
1350 FF_CODEC_DECODE_CB(mobiclip_decode),
1351 .flush = mobiclip_flush,
1352 .close = mobiclip_close,
1353 .p.capabilities = AV_CODEC_CAP_DR1,
1354 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1355 };
1356