2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * @file libavcodec/h264_cabac.c
24 * H.264 / AVC / MPEG4 part10 cabac decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
35 #include "h264_mvpred.h"
40 #include "x86/h264_i386.h"
46 /* Cabac pre state table */
48 static const int8_t cabac_context_init_I[460][2] =
51 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
52 { 2, 54 }, { 3, 74 }, { -28,127 }, { -23, 104 },
53 { -6, 53 }, { -1, 54 }, { 7, 51 },
55 /* 11 - 23 unsused for I */
56 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
57 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
58 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
62 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
63 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
64 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
65 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
68 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
69 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
70 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
80 { 13, 41 }, { 3, 62 },
83 { 0, 11 }, { 1, 55 }, { 0, 69 }, { -17, 127 },
84 { -13, 102 },{ 0, 82 }, { -7, 74 }, { -21, 107 },
85 { -27, 127 },{ -31, 127 },{ -24, 127 }, { -18, 95 },
86 { -27, 127 },{ -21, 114 },{ -30, 127 }, { -17, 123 },
87 { -12, 115 },{ -16, 122 },
90 { -11, 115 },{ -12, 63 }, { -2, 68 }, { -15, 84 },
91 { -13, 104 },{ -3, 70 }, { -8, 93 }, { -10, 90 },
92 { -30, 127 },{ -1, 74 }, { -6, 97 }, { -7, 91 },
93 { -20, 127 },{ -4, 56 }, { -5, 82 }, { -7, 76 },
97 { -7, 93 }, { -11, 87 }, { -3, 77 }, { -5, 71 },
98 { -4, 63 }, { -4, 68 }, { -12, 84 }, { -7, 62 },
99 { -7, 65 }, { 8, 61 }, { 5, 56 }, { -2, 66 },
100 { 1, 64 }, { 0, 61 }, { -2, 78 }, { 1, 50 },
101 { 7, 52 }, { 10, 35 }, { 0, 44 }, { 11, 38 },
102 { 1, 45 }, { 0, 46 }, { 5, 44 }, { 31, 17 },
103 { 1, 51 }, { 7, 50 }, { 28, 19 }, { 16, 33 },
104 { 14, 62 }, { -13, 108 },{ -15, 100 },
107 { -13, 101 },{ -13, 91 }, { -12, 94 }, { -10, 88 },
108 { -16, 84 }, { -10, 86 }, { -7, 83 }, { -13, 87 },
109 { -19, 94 }, { 1, 70 }, { 0, 72 }, { -5, 74 },
110 { 18, 59 }, { -8, 102 }, { -15, 100 }, { 0, 95 },
111 { -4, 75 }, { 2, 72 }, { -11, 75 }, { -3, 71 },
112 { 15, 46 }, { -13, 69 }, { 0, 62 }, { 0, 65 },
113 { 21, 37 }, { -15, 72 }, { 9, 57 }, { 16, 54 },
114 { 0, 62 }, { 12, 72 },
117 { 24, 0 }, { 15, 9 }, { 8, 25 }, { 13, 18 },
118 { 15, 9 }, { 13, 19 }, { 10, 37 }, { 12, 18 },
119 { 6, 29 }, { 20, 33 }, { 15, 30 }, { 4, 45 },
120 { 1, 58 }, { 0, 62 }, { 7, 61 }, { 12, 38 },
121 { 11, 45 }, { 15, 39 }, { 11, 42 }, { 13, 44 },
122 { 16, 45 }, { 12, 41 }, { 10, 49 }, { 30, 34 },
123 { 18, 42 }, { 10, 55 }, { 17, 51 }, { 17, 46 },
124 { 0, 89 }, { 26, -19 }, { 22, -17 },
127 { 26, -17 }, { 30, -25 }, { 28, -20 }, { 33, -23 },
128 { 37, -27 }, { 33, -23 }, { 40, -28 }, { 38, -17 },
129 { 33, -11 }, { 40, -15 }, { 41, -6 }, { 38, 1 },
130 { 41, 17 }, { 30, -6 }, { 27, 3 }, { 26, 22 },
131 { 37, -16 }, { 35, -4 }, { 38, -8 }, { 38, -3 },
132 { 37, 3 }, { 38, 5 }, { 42, 0 }, { 35, 16 },
133 { 39, 22 }, { 14, 48 }, { 27, 37 }, { 21, 60 },
134 { 12, 68 }, { 2, 97 },
137 { -3, 71 }, { -6, 42 }, { -5, 50 }, { -3, 54 },
138 { -2, 62 }, { 0, 58 }, { 1, 63 }, { -2, 72 },
139 { -1, 74 }, { -9, 91 }, { -5, 67 }, { -5, 27 },
140 { -3, 39 }, { -2, 44 }, { 0, 46 }, { -16, 64 },
141 { -8, 68 }, { -10, 78 }, { -6, 77 }, { -10, 86 },
142 { -12, 92 }, { -15, 55 }, { -10, 60 }, { -6, 62 },
146 { -12, 73 }, { -8, 76 }, { -7, 80 }, { -9, 88 },
147 { -17, 110 },{ -11, 97 }, { -20, 84 }, { -11, 79 },
148 { -6, 73 }, { -4, 74 }, { -13, 86 }, { -13, 96 },
149 { -11, 97 }, { -19, 117 },{ -8, 78 }, { -5, 33 },
150 { -4, 48 }, { -2, 53 }, { -3, 62 }, { -13, 71 },
151 { -10, 79 }, { -12, 86 }, { -13, 90 }, { -14, 97 },
153 /* 276 a bit special (not used, bypass is used instead) */
157 { -6, 93 }, { -6, 84 }, { -8, 79 }, { 0, 66 },
158 { -1, 71 }, { 0, 62 }, { -2, 60 }, { -2, 59 },
159 { -5, 75 }, { -3, 62 }, { -4, 58 }, { -9, 66 },
160 { -1, 79 }, { 0, 71 }, { 3, 68 }, { 10, 44 },
161 { -7, 62 }, { 15, 36 }, { 14, 40 }, { 16, 27 },
162 { 12, 29 }, { 1, 44 }, { 20, 36 }, { 18, 32 },
163 { 5, 42 }, { 1, 48 }, { 10, 62 }, { 17, 46 },
164 { 9, 64 }, { -12, 104 },{ -11, 97 },
167 { -16, 96 }, { -7, 88 }, { -8, 85 }, { -7, 85 },
168 { -9, 85 }, { -13, 88 }, { 4, 66 }, { -3, 77 },
169 { -3, 76 }, { -6, 76 }, { 10, 58 }, { -1, 76 },
170 { -1, 83 }, { -7, 99 }, { -14, 95 }, { 2, 95 },
171 { 0, 76 }, { -5, 74 }, { 0, 70 }, { -11, 75 },
172 { 1, 68 }, { 0, 65 }, { -14, 73 }, { 3, 62 },
173 { 4, 62 }, { -1, 68 }, { -13, 75 }, { 11, 55 },
174 { 5, 64 }, { 12, 70 },
177 { 15, 6 }, { 6, 19 }, { 7, 16 }, { 12, 14 },
178 { 18, 13 }, { 13, 11 }, { 13, 15 }, { 15, 16 },
179 { 12, 23 }, { 13, 23 }, { 15, 20 }, { 14, 26 },
180 { 14, 44 }, { 17, 40 }, { 17, 47 }, { 24, 17 },
181 { 21, 21 }, { 25, 22 }, { 31, 27 }, { 22, 29 },
182 { 19, 35 }, { 14, 50 }, { 10, 57 }, { 7, 63 },
183 { -2, 77 }, { -4, 82 }, { -3, 94 }, { 9, 69 },
184 { -12, 109 },{ 36, -35 }, { 36, -34 },
187 { 32, -26 }, { 37, -30 }, { 44, -32 }, { 34, -18 },
188 { 34, -15 }, { 40, -15 }, { 33, -7 }, { 35, -5 },
189 { 33, 0 }, { 38, 2 }, { 33, 13 }, { 23, 35 },
190 { 13, 58 }, { 29, -3 }, { 26, 0 }, { 22, 30 },
191 { 31, -7 }, { 35, -15 }, { 34, -3 }, { 34, 3 },
192 { 36, -1 }, { 34, 5 }, { 32, 11 }, { 35, 5 },
193 { 34, 12 }, { 39, 11 }, { 30, 29 }, { 34, 26 },
194 { 29, 39 }, { 19, 66 },
197 { 31, 21 }, { 31, 31 }, { 25, 50 },
198 { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11, 85 },
199 { -15, 92 }, { -14, 89 }, { -26, 71 }, { -15, 81 },
200 { -14, 80 }, { 0, 68 }, { -14, 70 }, { -24, 56 },
201 { -23, 68 }, { -24, 50 }, { -11, 74 }, { 23, -13 },
202 { 26, -13 }, { 40, -15 }, { 49, -14 }, { 44, 3 },
203 { 45, 6 }, { 44, 34 }, { 33, 54 }, { 19, 82 },
204 { -3, 75 }, { -1, 23 }, { 1, 34 }, { 1, 43 },
205 { 0, 54 }, { -2, 55 }, { 0, 61 }, { 1, 64 },
206 { 0, 68 }, { -9, 92 },
209 { -14, 106 }, { -13, 97 }, { -15, 90 }, { -12, 90 },
210 { -18, 88 }, { -10, 73 }, { -9, 79 }, { -14, 86 },
211 { -10, 73 }, { -10, 70 }, { -10, 69 }, { -5, 66 },
212 { -9, 64 }, { -5, 58 }, { 2, 59 }, { 21, -10 },
213 { 24, -11 }, { 28, -8 }, { 28, -1 }, { 29, 3 },
214 { 29, 9 }, { 35, 20 }, { 29, 36 }, { 14, 67 }
217 static const int8_t cabac_context_init_PB[3][460][2] =
219 /* i_cabac_init_idc == 0 */
222 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
223 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
224 { -6, 53 }, { -1, 54 }, { 7, 51 },
227 { 23, 33 }, { 23, 2 }, { 21, 0 }, { 1, 9 },
228 { 0, 49 }, { -37, 118 }, { 5, 57 }, { -13, 78 },
229 { -11, 65 }, { 1, 62 }, { 12, 49 }, { -4, 73 },
233 { 18, 64 }, { 9, 43 }, { 29, 0 }, { 26, 67 },
234 { 16, 90 }, { 9, 104 }, { -46, 127 }, { -20, 104 },
235 { 1, 67 }, { -13, 78 }, { -11, 65 }, { 1, 62 },
236 { -6, 86 }, { -17, 95 }, { -6, 61 }, { 9, 45 },
239 { -3, 69 }, { -6, 81 }, { -11, 96 }, { 6, 55 },
240 { 7, 67 }, { -5, 86 }, { 2, 88 }, { 0, 58 },
241 { -3, 76 }, { -10, 94 }, { 5, 54 }, { 4, 69 },
242 { -3, 81 }, { 0, 88 },
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
246 { -7, 72 }, { 1, 58 },
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
251 { 13, 41 }, { 3, 62 },
254 { 0, 45 }, { -4, 78 }, { -3, 96 }, { -27, 126 },
255 { -28, 98 }, { -25, 101 }, { -23, 67 }, { -28, 82 },
256 { -20, 94 }, { -16, 83 }, { -22, 110 }, { -21, 91 },
257 { -18, 102 }, { -13, 93 }, { -29, 127 }, { -7, 92 },
258 { -5, 89 }, { -7, 96 }, { -13, 108 }, { -3, 46 },
259 { -1, 65 }, { -1, 57 }, { -9, 93 }, { -3, 74 },
260 { -9, 92 }, { -8, 87 }, { -23, 126 }, { 5, 54 },
261 { 6, 60 }, { 6, 59 }, { 6, 69 }, { -1, 48 },
262 { 0, 68 }, { -4, 69 }, { -8, 88 },
265 { -2, 85 }, { -6, 78 }, { -1, 75 }, { -7, 77 },
266 { 2, 54 }, { 5, 50 }, { -3, 68 }, { 1, 50 },
267 { 6, 42 }, { -4, 81 }, { 1, 63 }, { -4, 70 },
268 { 0, 67 }, { 2, 57 }, { -2, 76 }, { 11, 35 },
269 { 4, 64 }, { 1, 61 }, { 11, 35 }, { 18, 25 },
270 { 12, 24 }, { 13, 29 }, { 13, 36 }, { -10, 93 },
271 { -7, 73 }, { -2, 73 }, { 13, 46 }, { 9, 49 },
272 { -7, 100 }, { 9, 53 }, { 2, 53 }, { 5, 53 },
273 { -2, 61 }, { 0, 56 }, { 0, 56 }, { -13, 63 },
274 { -5, 60 }, { -1, 62 }, { 4, 57 }, { -6, 69 },
275 { 4, 57 }, { 14, 39 }, { 4, 51 }, { 13, 68 },
276 { 3, 64 }, { 1, 61 }, { 9, 63 }, { 7, 50 },
277 { 16, 39 }, { 5, 44 }, { 4, 52 }, { 11, 48 },
278 { -5, 60 }, { -1, 59 }, { 0, 59 }, { 22, 33 },
279 { 5, 44 }, { 14, 43 }, { -1, 78 }, { 0, 60 },
283 { 11, 28 }, { 2, 40 }, { 3, 44 }, { 0, 49 },
284 { 0, 46 }, { 2, 44 }, { 2, 51 }, { 0, 47 },
285 { 4, 39 }, { 2, 62 }, { 6, 46 }, { 0, 54 },
286 { 3, 54 }, { 2, 58 }, { 4, 63 }, { 6, 51 },
287 { 6, 57 }, { 7, 53 }, { 6, 52 }, { 6, 55 },
288 { 11, 45 }, { 14, 36 }, { 8, 53 }, { -1, 82 },
289 { 7, 55 }, { -3, 78 }, { 15, 46 }, { 22, 31 },
290 { -1, 84 }, { 25, 7 }, { 30, -7 }, { 28, 3 },
291 { 28, 4 }, { 32, 0 }, { 34, -1 }, { 30, 6 },
292 { 30, 6 }, { 32, 9 }, { 31, 19 }, { 26, 27 },
293 { 26, 30 }, { 37, 20 }, { 28, 34 }, { 17, 70 },
294 { 1, 67 }, { 5, 59 }, { 9, 67 }, { 16, 30 },
295 { 18, 32 }, { 18, 35 }, { 22, 29 }, { 24, 31 },
296 { 23, 38 }, { 18, 43 }, { 20, 41 }, { 11, 63 },
297 { 9, 59 }, { 9, 64 }, { -1, 94 }, { -2, 89 },
301 { -6, 76 }, { -2, 44 }, { 0, 45 }, { 0, 52 },
302 { -3, 64 }, { -2, 59 }, { -4, 70 }, { -4, 75 },
303 { -8, 82 }, { -17, 102 }, { -9, 77 }, { 3, 24 },
304 { 0, 42 }, { 0, 48 }, { 0, 55 }, { -6, 59 },
305 { -7, 71 }, { -12, 83 }, { -11, 87 }, { -30, 119 },
306 { 1, 58 }, { -3, 29 }, { -1, 36 }, { 1, 38 },
307 { 2, 43 }, { -6, 55 }, { 0, 58 }, { 0, 64 },
308 { -3, 74 }, { -10, 90 }, { 0, 70 }, { -4, 29 },
309 { 5, 31 }, { 7, 42 }, { 1, 59 }, { -2, 58 },
310 { -3, 72 }, { -3, 81 }, { -11, 97 }, { 0, 58 },
311 { 8, 5 }, { 10, 14 }, { 14, 18 }, { 13, 27 },
312 { 2, 40 }, { 0, 58 }, { -3, 70 }, { -6, 79 },
315 /* 276 a bit special (not used, bypass is used instead) */
319 { -13, 106 }, { -16, 106 }, { -10, 87 }, { -21, 114 },
320 { -18, 110 }, { -14, 98 }, { -22, 110 }, { -21, 106 },
321 { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
322 { -10, 96 }, { -12, 95 }, { -5, 91 }, { -9, 93 },
323 { -22, 94 }, { -5, 86 }, { 9, 67 }, { -4, 80 },
324 { -10, 85 }, { -1, 70 }, { 7, 60 }, { 9, 58 },
325 { 5, 61 }, { 12, 50 }, { 15, 50 }, { 18, 49 },
326 { 17, 54 }, { 10, 41 }, { 7, 46 }, { -1, 51 },
327 { 7, 49 }, { 8, 52 }, { 9, 41 }, { 6, 47 },
328 { 2, 55 }, { 13, 41 }, { 10, 44 }, { 6, 50 },
329 { 5, 53 }, { 13, 49 }, { 4, 63 }, { 6, 64 },
330 { -2, 69 }, { -2, 59 }, { 6, 70 }, { 10, 44 },
331 { 9, 31 }, { 12, 43 }, { 3, 53 }, { 14, 34 },
332 { 10, 38 }, { -3, 52 }, { 13, 40 }, { 17, 32 },
333 { 7, 44 }, { 7, 38 }, { 13, 50 }, { 10, 57 },
337 { 14, 11 }, { 11, 14 }, { 9, 11 }, { 18, 11 },
338 { 21, 9 }, { 23, -2 }, { 32, -15 }, { 32, -15 },
339 { 34, -21 }, { 39, -23 }, { 42, -33 }, { 41, -31 },
340 { 46, -28 }, { 38, -12 }, { 21, 29 }, { 45, -24 },
341 { 53, -45 }, { 48, -26 }, { 65, -43 }, { 43, -19 },
342 { 39, -10 }, { 30, 9 }, { 18, 26 }, { 20, 27 },
343 { 0, 57 }, { -14, 82 }, { -5, 75 }, { -19, 97 },
344 { -35, 125 }, { 27, 0 }, { 28, 0 }, { 31, -4 },
345 { 27, 6 }, { 34, 8 }, { 30, 10 }, { 24, 22 },
346 { 33, 19 }, { 22, 32 }, { 26, 31 }, { 21, 41 },
347 { 26, 44 }, { 23, 47 }, { 16, 65 }, { 14, 71 },
348 { 8, 60 }, { 6, 63 }, { 17, 65 }, { 21, 24 },
349 { 23, 20 }, { 26, 23 }, { 27, 32 }, { 28, 23 },
350 { 28, 24 }, { 23, 40 }, { 24, 32 }, { 28, 29 },
351 { 23, 42 }, { 19, 57 }, { 22, 53 }, { 22, 61 },
355 { 12, 40 }, { 11, 51 }, { 14, 59 },
356 { -4, 79 }, { -7, 71 }, { -5, 69 }, { -9, 70 },
357 { -8, 66 }, { -10, 68 }, { -19, 73 }, { -12, 69 },
358 { -16, 70 }, { -15, 67 }, { -20, 62 }, { -19, 70 },
359 { -16, 66 }, { -22, 65 }, { -20, 63 }, { 9, -2 },
360 { 26, -9 }, { 33, -9 }, { 39, -7 }, { 41, -2 },
361 { 45, 3 }, { 49, 9 }, { 45, 27 }, { 36, 59 },
362 { -6, 66 }, { -7, 35 }, { -7, 42 }, { -8, 45 },
363 { -5, 48 }, { -12, 56 }, { -6, 60 }, { -5, 62 },
364 { -8, 66 }, { -8, 76 },
367 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
368 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
369 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
370 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 21, -13 },
371 { 33, -14 }, { 39, -7 }, { 46, -2 }, { 51, 2 },
372 { 60, 6 }, { 61, 17 }, { 55, 34 }, { 42, 62 },
375 /* i_cabac_init_idc == 1 */
378 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
379 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
380 { -6, 53 }, { -1, 54 }, { 7, 51 },
383 { 22, 25 }, { 34, 0 }, { 16, 0 }, { -2, 9 },
384 { 4, 41 }, { -29, 118 }, { 2, 65 }, { -6, 71 },
385 { -13, 79 }, { 5, 52 }, { 9, 50 }, { -3, 70 },
389 { 26, 34 }, { 19, 22 }, { 40, 0 }, { 57, 2 },
390 { 41, 36 }, { 26, 69 }, { -45, 127 }, { -15, 101 },
391 { -4, 76 }, { -6, 71 }, { -13, 79 }, { 5, 52 },
392 { 6, 69 }, { -13, 90 }, { 0, 52 }, { 8, 43 },
395 { -2, 69 },{ -5, 82 },{ -10, 96 },{ 2, 59 },
396 { 2, 75 },{ -3, 87 },{ -3, 100 },{ 1, 56 },
397 { -3, 74 },{ -6, 85 },{ 0, 59 },{ -3, 81 },
398 { -7, 86 },{ -5, 95 },
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
402 { -5, 72 },{ 0, 61 },
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
407 { 13, 41 }, { 3, 62 },
410 { 13, 15 }, { 7, 51 }, { 2, 80 }, { -39, 127 },
411 { -18, 91 }, { -17, 96 }, { -26, 81 }, { -35, 98 },
412 { -24, 102 }, { -23, 97 }, { -27, 119 }, { -24, 99 },
413 { -21, 110 }, { -18, 102 }, { -36, 127 }, { 0, 80 },
414 { -5, 89 }, { -7, 94 }, { -4, 92 }, { 0, 39 },
415 { 0, 65 }, { -15, 84 }, { -35, 127 }, { -2, 73 },
416 { -12, 104 }, { -9, 91 }, { -31, 127 }, { 3, 55 },
417 { 7, 56 }, { 7, 55 }, { 8, 61 }, { -3, 53 },
418 { 0, 68 }, { -7, 74 }, { -9, 88 },
421 { -13, 103 }, { -13, 91 }, { -9, 89 }, { -14, 92 },
422 { -8, 76 }, { -12, 87 }, { -23, 110 }, { -24, 105 },
423 { -10, 78 }, { -20, 112 }, { -17, 99 }, { -78, 127 },
424 { -70, 127 }, { -50, 127 }, { -46, 127 }, { -4, 66 },
425 { -5, 78 }, { -4, 71 }, { -8, 72 }, { 2, 59 },
426 { -1, 55 }, { -7, 70 }, { -6, 75 }, { -8, 89 },
427 { -34, 119 }, { -3, 75 }, { 32, 20 }, { 30, 22 },
428 { -44, 127 }, { 0, 54 }, { -5, 61 }, { 0, 58 },
429 { -1, 60 }, { -3, 61 }, { -8, 67 }, { -25, 84 },
430 { -14, 74 }, { -5, 65 }, { 5, 52 }, { 2, 57 },
431 { 0, 61 }, { -9, 69 }, { -11, 70 }, { 18, 55 },
432 { -4, 71 }, { 0, 58 }, { 7, 61 }, { 9, 41 },
433 { 18, 25 }, { 9, 32 }, { 5, 43 }, { 9, 47 },
434 { 0, 44 }, { 0, 51 }, { 2, 46 }, { 19, 38 },
435 { -4, 66 }, { 15, 38 }, { 12, 42 }, { 9, 34 },
439 { 4, 45 }, { 10, 28 }, { 10, 31 }, { 33, -11 },
440 { 52, -43 }, { 18, 15 }, { 28, 0 }, { 35, -22 },
441 { 38, -25 }, { 34, 0 }, { 39, -18 }, { 32, -12 },
442 { 102, -94 }, { 0, 0 }, { 56, -15 }, { 33, -4 },
443 { 29, 10 }, { 37, -5 }, { 51, -29 }, { 39, -9 },
444 { 52, -34 }, { 69, -58 }, { 67, -63 }, { 44, -5 },
445 { 32, 7 }, { 55, -29 }, { 32, 1 }, { 0, 0 },
446 { 27, 36 }, { 33, -25 }, { 34, -30 }, { 36, -28 },
447 { 38, -28 }, { 38, -27 }, { 34, -18 }, { 35, -16 },
448 { 34, -14 }, { 32, -8 }, { 37, -6 }, { 35, 0 },
449 { 30, 10 }, { 28, 18 }, { 26, 25 }, { 29, 41 },
450 { 0, 75 }, { 2, 72 }, { 8, 77 }, { 14, 35 },
451 { 18, 31 }, { 17, 35 }, { 21, 30 }, { 17, 45 },
452 { 20, 42 }, { 18, 45 }, { 27, 26 }, { 16, 54 },
453 { 7, 66 }, { 16, 56 }, { 11, 73 }, { 10, 67 },
457 { -23, 112 }, { -15, 71 }, { -7, 61 }, { 0, 53 },
458 { -5, 66 }, { -11, 77 }, { -9, 80 }, { -9, 84 },
459 { -10, 87 }, { -34, 127 }, { -21, 101 }, { -3, 39 },
460 { -5, 53 }, { -7, 61 }, { -11, 75 }, { -15, 77 },
461 { -17, 91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
462 { -11, 76 }, { -10, 44 }, { -10, 52 }, { -10, 57 },
463 { -9, 58 }, { -16, 72 }, { -7, 69 }, { -4, 69 },
464 { -5, 74 }, { -9, 86 }, { 2, 66 }, { -9, 34 },
465 { 1, 32 }, { 11, 31 }, { 5, 52 }, { -2, 55 },
466 { -2, 67 }, { 0, 73 }, { -8, 89 }, { 3, 52 },
467 { 7, 4 }, { 10, 8 }, { 17, 8 }, { 16, 19 },
468 { 3, 37 }, { -1, 61 }, { -5, 73 }, { -1, 70 },
471 /* 276 a bit special (not used, bypass is used instead) */
475 { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
476 { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
477 { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
478 { -10, 95 }, { -14, 100 }, { -8, 95 }, { -17, 111 },
479 { -28, 114 }, { -6, 89 }, { -2, 80 }, { -4, 82 },
480 { -9, 85 }, { -8, 81 }, { -1, 72 }, { 5, 64 },
481 { 1, 67 }, { 9, 56 }, { 0, 69 }, { 1, 69 },
482 { 7, 69 }, { -7, 69 }, { -6, 67 }, { -16, 77 },
483 { -2, 64 }, { 2, 61 }, { -6, 67 }, { -3, 64 },
484 { 2, 57 }, { -3, 65 }, { -3, 66 }, { 0, 62 },
485 { 9, 51 }, { -1, 66 }, { -2, 71 }, { -2, 75 },
486 { -1, 70 }, { -9, 72 }, { 14, 60 }, { 16, 37 },
487 { 0, 47 }, { 18, 35 }, { 11, 37 }, { 12, 41 },
488 { 10, 41 }, { 2, 48 }, { 12, 41 }, { 13, 41 },
489 { 0, 59 }, { 3, 50 }, { 19, 40 }, { 3, 66 },
493 { 19, -6 }, { 18, -6 }, { 14, 0 }, { 26, -12 },
494 { 31, -16 }, { 33, -25 }, { 33, -22 }, { 37, -28 },
495 { 39, -30 }, { 42, -30 }, { 47, -42 }, { 45, -36 },
496 { 49, -34 }, { 41, -17 }, { 32, 9 }, { 69, -71 },
497 { 63, -63 }, { 66, -64 }, { 77, -74 }, { 54, -39 },
498 { 52, -35 }, { 41, -10 }, { 36, 0 }, { 40, -1 },
499 { 30, 14 }, { 28, 26 }, { 23, 37 }, { 12, 55 },
500 { 11, 65 }, { 37, -33 }, { 39, -36 }, { 40, -37 },
501 { 38, -30 }, { 46, -33 }, { 42, -30 }, { 40, -24 },
502 { 49, -29 }, { 38, -12 }, { 40, -10 }, { 38, -3 },
503 { 46, -5 }, { 31, 20 }, { 29, 30 }, { 25, 44 },
504 { 12, 48 }, { 11, 49 }, { 26, 45 }, { 22, 22 },
505 { 23, 22 }, { 27, 21 }, { 33, 20 }, { 26, 28 },
506 { 30, 24 }, { 27, 34 }, { 18, 42 }, { 25, 39 },
507 { 18, 50 }, { 12, 70 }, { 21, 54 }, { 14, 71 },
511 { 25, 32 }, { 21, 49 }, { 21, 54 },
512 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
513 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
514 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
515 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 17, -10 },
516 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
517 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
518 { -5, 71 }, { 0, 24 }, { -1, 36 }, { -2, 42 },
519 { -2, 52 }, { -9, 57 }, { -6, 63 }, { -4, 65 },
520 { -4, 67 }, { -7, 82 },
523 { -3, 81 }, { -3, 76 }, { -7, 72 }, { -6, 78 },
524 { -12, 72 }, { -14, 68 }, { -3, 70 }, { -6, 76 },
525 { -5, 66 }, { -5, 62 }, { 0, 57 }, { -4, 61 },
526 { -9, 60 }, { 1, 54 }, { 2, 58 }, { 17, -10 },
527 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
528 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
531 /* i_cabac_init_idc == 2 */
534 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
535 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
536 { -6, 53 }, { -1, 54 }, { 7, 51 },
539 { 29, 16 }, { 25, 0 }, { 14, 0 }, { -10, 51 },
540 { -3, 62 }, { -27, 99 }, { 26, 16 }, { -4, 85 },
541 { -24, 102 }, { 5, 57 }, { 6, 57 }, { -17, 73 },
545 { 20, 40 }, { 20, 10 }, { 29, 0 }, { 54, 0 },
546 { 37, 42 }, { 12, 97 }, { -32, 127 }, { -22, 117 },
547 { -2, 74 }, { -4, 85 }, { -24, 102 }, { 5, 57 },
548 { -6, 93 }, { -14, 88 }, { -6, 44 }, { 4, 55 },
551 { -11, 89 },{ -15, 103 },{ -21, 116 },{ 19, 57 },
552 { 20, 58 },{ 4, 84 },{ 6, 96 },{ 1, 63 },
553 { -5, 85 },{ -13, 106 },{ 5, 63 },{ 6, 75 },
554 { -3, 90 },{ -1, 101 },
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
558 { -7, 50 },{ 1, 60 },
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
563 { 13, 41 }, { 3, 62 },
566 { 7, 34 }, { -9, 88 }, { -20, 127 }, { -36, 127 },
567 { -17, 91 }, { -14, 95 }, { -25, 84 }, { -25, 86 },
568 { -12, 89 }, { -17, 91 }, { -31, 127 }, { -14, 76 },
569 { -18, 103 }, { -13, 90 }, { -37, 127 }, { 11, 80 },
570 { 5, 76 }, { 2, 84 }, { 5, 78 }, { -6, 55 },
571 { 4, 61 }, { -14, 83 }, { -37, 127 }, { -5, 79 },
572 { -11, 104 }, { -11, 91 }, { -30, 127 }, { 0, 65 },
573 { -2, 79 }, { 0, 72 }, { -4, 92 }, { -6, 56 },
574 { 3, 68 }, { -8, 71 }, { -13, 98 },
577 { -4, 86 }, { -12, 88 }, { -5, 82 }, { -3, 72 },
578 { -4, 67 }, { -8, 72 }, { -16, 89 }, { -9, 69 },
579 { -1, 59 }, { 5, 66 }, { 4, 57 }, { -4, 71 },
580 { -2, 71 }, { 2, 58 }, { -1, 74 }, { -4, 44 },
581 { -1, 69 }, { 0, 62 }, { -7, 51 }, { -4, 47 },
582 { -6, 42 }, { -3, 41 }, { -6, 53 }, { 8, 76 },
583 { -9, 78 }, { -11, 83 }, { 9, 52 }, { 0, 67 },
584 { -5, 90 }, { 1, 67 }, { -15, 72 }, { -5, 75 },
585 { -8, 80 }, { -21, 83 }, { -21, 64 }, { -13, 31 },
586 { -25, 64 }, { -29, 94 }, { 9, 75 }, { 17, 63 },
587 { -8, 74 }, { -5, 35 }, { -2, 27 }, { 13, 91 },
588 { 3, 65 }, { -7, 69 }, { 8, 77 }, { -10, 66 },
589 { 3, 62 }, { -3, 68 }, { -20, 81 }, { 0, 30 },
590 { 1, 7 }, { -3, 23 }, { -21, 74 }, { 16, 66 },
591 { -23, 124 }, { 17, 37 }, { 44, -18 }, { 50, -34 },
595 { 4, 39 }, { 0, 42 }, { 7, 34 }, { 11, 29 },
596 { 8, 31 }, { 6, 37 }, { 7, 42 }, { 3, 40 },
597 { 8, 33 }, { 13, 43 }, { 13, 36 }, { 4, 47 },
598 { 3, 55 }, { 2, 58 }, { 6, 60 }, { 8, 44 },
599 { 11, 44 }, { 14, 42 }, { 7, 48 }, { 4, 56 },
600 { 4, 52 }, { 13, 37 }, { 9, 49 }, { 19, 58 },
601 { 10, 48 }, { 12, 45 }, { 0, 69 }, { 20, 33 },
602 { 8, 63 }, { 35, -18 }, { 33, -25 }, { 28, -3 },
603 { 24, 10 }, { 27, 0 }, { 34, -14 }, { 52, -44 },
604 { 39, -24 }, { 19, 17 }, { 31, 25 }, { 36, 29 },
605 { 24, 33 }, { 34, 15 }, { 30, 20 }, { 22, 73 },
606 { 20, 34 }, { 19, 31 }, { 27, 44 }, { 19, 16 },
607 { 15, 36 }, { 15, 36 }, { 21, 28 }, { 25, 21 },
608 { 30, 20 }, { 31, 12 }, { 27, 16 }, { 24, 42 },
609 { 0, 93 }, { 14, 56 }, { 15, 57 }, { 26, 38 },
613 { -24, 115 }, { -22, 82 }, { -9, 62 }, { 0, 53 },
614 { 0, 59 }, { -14, 85 }, { -13, 89 }, { -13, 94 },
615 { -11, 92 }, { -29, 127 }, { -21, 100 }, { -14, 57 },
616 { -12, 67 }, { -11, 71 }, { -10, 77 }, { -21, 85 },
617 { -16, 88 }, { -23, 104 }, { -15, 98 }, { -37, 127 },
618 { -10, 82 }, { -8, 48 }, { -8, 61 }, { -8, 66 },
619 { -7, 70 }, { -14, 75 }, { -10, 79 }, { -9, 83 },
620 { -12, 92 }, { -18, 108 }, { -4, 79 }, { -22, 69 },
621 { -16, 75 }, { -2, 58 }, { 1, 58 }, { -13, 78 },
622 { -9, 83 }, { -4, 81 }, { -13, 99 }, { -13, 81 },
623 { -6, 38 }, { -13, 62 }, { -6, 58 }, { -2, 59 },
624 { -16, 73 }, { -10, 76 }, { -13, 86 }, { -9, 83 },
627 /* 276 a bit special (not used, bypass is used instead) */
631 { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
632 { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
633 { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
634 { -10, 94 }, { -15, 102 }, { -10, 99 }, { -13, 106 },
635 { -50, 127 }, { -5, 92 }, { 17, 57 }, { -5, 86 },
636 { -13, 94 }, { -12, 91 }, { -2, 77 }, { 0, 71 },
637 { -1, 73 }, { 4, 64 }, { -7, 81 }, { 5, 64 },
638 { 15, 57 }, { 1, 67 }, { 0, 68 }, { -10, 67 },
639 { 1, 68 }, { 0, 77 }, { 2, 64 }, { 0, 68 },
640 { -5, 78 }, { 7, 55 }, { 5, 59 }, { 2, 65 },
641 { 14, 54 }, { 15, 44 }, { 5, 60 }, { 2, 70 },
642 { -2, 76 }, { -18, 86 }, { 12, 70 }, { 5, 64 },
643 { -12, 70 }, { 11, 55 }, { 5, 56 }, { 0, 69 },
644 { 2, 65 }, { -6, 74 }, { 5, 54 }, { 7, 54 },
645 { -6, 76 }, { -11, 82 }, { -2, 77 }, { -2, 77 },
649 { 17, -13 }, { 16, -9 }, { 17, -12 }, { 27, -21 },
650 { 37, -30 }, { 41, -40 }, { 42, -41 }, { 48, -47 },
651 { 39, -32 }, { 46, -40 }, { 52, -51 }, { 46, -41 },
652 { 52, -39 }, { 43, -19 }, { 32, 11 }, { 61, -55 },
653 { 56, -46 }, { 62, -50 }, { 81, -67 }, { 45, -20 },
654 { 35, -2 }, { 28, 15 }, { 34, 1 }, { 39, 1 },
655 { 30, 17 }, { 20, 38 }, { 18, 45 }, { 15, 54 },
656 { 0, 79 }, { 36, -16 }, { 37, -14 }, { 37, -17 },
657 { 32, 1 }, { 34, 15 }, { 29, 15 }, { 24, 25 },
658 { 34, 22 }, { 31, 16 }, { 35, 18 }, { 31, 28 },
659 { 33, 41 }, { 36, 28 }, { 27, 47 }, { 21, 62 },
660 { 18, 31 }, { 19, 26 }, { 36, 24 }, { 24, 23 },
661 { 27, 16 }, { 24, 30 }, { 31, 29 }, { 22, 41 },
662 { 22, 42 }, { 16, 60 }, { 15, 52 }, { 14, 60 },
663 { 3, 78 }, { -16, 123 }, { 21, 53 }, { 22, 56 },
667 { 21, 33 }, { 19, 50 }, { 17, 61 },
668 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
669 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
670 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
671 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
672 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
673 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
674 { -9, 71 }, { -7, 37 }, { -8, 44 }, { -11, 49 },
675 { -10, 56 }, { -12, 59 }, { -8, 63 }, { -9, 67 },
676 { -6, 68 }, { -10, 79 },
679 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
680 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
681 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
682 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
683 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
684 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
688 void ff_h264_init_cabac_states(H264Context *h) {
689 MpegEncContext * const s = &h->s;
692 /* calculate pre-state */
693 for( i= 0; i < 460; i++ ) {
695 if( h->slice_type_nos == FF_I_TYPE )
696 pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
698 pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
701 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
703 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
707 static int decode_cabac_field_decoding_flag(H264Context *h) {
708 MpegEncContext * const s = &h->s;
709 const long mba_xy = h->mb_xy - 1L;
710 const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
712 unsigned long ctx = 0;
714 ctx += (s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
715 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
721 uint8_t *state= &h->cabac_state[ctx_base];
725 MpegEncContext * const s = &h->s;
726 const int mba_xy = h->left_mb_xy[0];
727 const int mbb_xy = h->top_mb_xy;
729 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
731 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
733 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
737 if( get_cabac_noinline( &h->cabac, state ) == 0 )
741 if( get_cabac_terminate( &h->cabac ) )
744 mb_type = 1; /* I16x16 */
745 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
746 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
747 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
748 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
749 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
753 static int decode_cabac_mb_type_b( H264Context *h ) {
754 MpegEncContext * const s = &h->s;
756 const int mba_xy = h->left_mb_xy[0];
757 const int mbb_xy = h->top_mb_xy;
760 assert(h->slice_type_nos == FF_B_TYPE);
762 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
764 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
767 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
768 return 0; /* B_Direct_16x16 */
770 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
771 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
774 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
775 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
776 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
777 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
779 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
780 else if( bits == 13 ) {
781 return decode_cabac_intra_mb_type(h, 32, 0) + 23;
782 } else if( bits == 14 )
783 return 11; /* B_L1_L0_8x16 */
784 else if( bits == 15 )
785 return 22; /* B_8x8 */
787 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
788 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
791 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
792 MpegEncContext * const s = &h->s;
796 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
797 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
800 && h->slice_table[mba_xy] == h->slice_num
801 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
802 mba_xy += s->mb_stride;
804 mbb_xy = mb_xy - s->mb_stride;
806 && h->slice_table[mbb_xy] == h->slice_num
807 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
808 mbb_xy -= s->mb_stride;
810 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
812 int mb_xy = h->mb_xy;
814 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
817 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
819 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
822 if( h->slice_type_nos == FF_B_TYPE )
824 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
827 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
830 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
833 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
834 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
835 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
837 if( mode >= pred_mode )
843 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
844 const int mba_xy = h->left_mb_xy[0];
845 const int mbb_xy = h->top_mb_xy;
849 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
850 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
853 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
856 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
859 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
861 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
867 static int decode_cabac_mb_cbp_luma( H264Context *h) {
868 int cbp_b, cbp_a, ctx, cbp = 0;
873 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
874 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
875 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08);
876 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
877 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01);
878 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
879 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02);
880 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
883 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
887 cbp_a = (h->left_cbp>>4)&0x03;
888 cbp_b = (h-> top_cbp>>4)&0x03;
891 if( cbp_a > 0 ) ctx++;
892 if( cbp_b > 0 ) ctx += 2;
893 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
897 if( cbp_a == 2 ) ctx++;
898 if( cbp_b == 2 ) ctx += 2;
899 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
902 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
903 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
905 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
907 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
911 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
913 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
914 return 0; /* B_Direct_8x8 */
915 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
916 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
918 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
919 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
920 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
923 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
924 type += get_cabac( &h->cabac, &h->cabac_state[39] );
928 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
929 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
932 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
933 int refa = h->ref_cache[list][scan8[n] - 1];
934 int refb = h->ref_cache[list][scan8[n] - 8];
938 if( h->slice_type_nos == FF_B_TYPE) {
939 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
941 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
950 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
953 if(ref >= 32 /*h->ref_list[list]*/){
960 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
961 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
962 abs( h->mvd_cache[list][scan8[n] - 8][l] );
963 int ctxbase = (l == 0) ? 40 : 47;
965 int ctx = (amvd>2) + (amvd>32);
967 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
972 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
980 while( get_cabac_bypass( &h->cabac ) ) {
984 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
989 if( get_cabac_bypass( &h->cabac ) )
993 return get_cabac_bypass_sign( &h->cabac, -mvd );
996 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
1002 nza = h->left_cbp&0x100;
1003 nzb = h-> top_cbp&0x100;
1005 nza = (h->left_cbp>>(6+idx))&0x01;
1006 nzb = (h-> top_cbp>>(6+idx))&0x01;
1009 assert(cat == 1 || cat == 2 || cat == 4);
1010 nza = h->non_zero_count_cache[scan8[idx] - 1];
1011 nzb = h->non_zero_count_cache[scan8[idx] - 8];
1020 return ctx + 4 * cat;
1023 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
1024 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1025 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1026 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1027 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1030 static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
1031 static const int significant_coeff_flag_offset[2][6] = {
1032 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1033 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1035 static const int last_coeff_flag_offset[2][6] = {
1036 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1037 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1039 static const int coeff_abs_level_m1_offset[6] = {
1040 227+0, 227+10, 227+20, 227+30, 227+39, 426
1042 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1043 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1044 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1045 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1046 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1047 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1048 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1049 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1050 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1052 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1053 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1054 * map node ctx => cabac ctx for level=1 */
1055 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1056 /* map node ctx => cabac ctx for level>1 */
1057 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1058 static const uint8_t coeff_abs_level_transition[2][8] = {
1059 /* update node ctx after decoding a level=1 */
1060 { 1, 2, 3, 3, 4, 5, 6, 7 },
1061 /* update node ctx after decoding a level>1 */
1062 { 4, 4, 4, 4, 5, 6, 7, 7 }
1068 int coeff_count = 0;
1071 uint8_t *significant_coeff_ctx_base;
1072 uint8_t *last_coeff_ctx_base;
1073 uint8_t *abs_level_m1_ctx_base;
1076 #define CABAC_ON_STACK
1078 #ifdef CABAC_ON_STACK
1081 cc.range = h->cabac.range;
1082 cc.low = h->cabac.low;
1083 cc.bytestream= h->cabac.bytestream;
1085 #define CC &h->cabac
1089 /* cat: 0-> DC 16x16 n = 0
1090 * 1-> AC 16x16 n = luma4x4idx
1091 * 2-> Luma4x4 n = luma4x4idx
1092 * 3-> DC Chroma n = iCbCr
1093 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1094 * 5-> Luma8x8 n = 4 * luma8x8idx
1097 /* read coded block flag */
1098 if( is_dc || cat != 5 ) {
1099 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1101 h->non_zero_count_cache[scan8[n]] = 0;
1103 #ifdef CABAC_ON_STACK
1104 h->cabac.range = cc.range ;
1105 h->cabac.low = cc.low ;
1106 h->cabac.bytestream= cc.bytestream;
1112 significant_coeff_ctx_base = h->cabac_state
1113 + significant_coeff_flag_offset[MB_FIELD][cat];
1114 last_coeff_ctx_base = h->cabac_state
1115 + last_coeff_flag_offset[MB_FIELD][cat];
1116 abs_level_m1_ctx_base = h->cabac_state
1117 + coeff_abs_level_m1_offset[cat];
1119 if( !is_dc && cat == 5 ) {
1120 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1121 for(last= 0; last < coefs; last++) { \
1122 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1123 if( get_cabac( CC, sig_ctx )) { \
1124 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1125 index[coeff_count++] = last; \
1126 if( get_cabac( CC, last_ctx ) ) { \
1132 if( last == max_coeff -1 ) {\
1133 index[coeff_count++] = last;\
1135 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1136 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1137 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1139 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1141 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1143 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1146 assert(coeff_count > 0);
1150 h->cbp_table[h->mb_xy] |= 0x100;
1152 h->cbp_table[h->mb_xy] |= 0x40 << n;
1155 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1157 assert( cat == 1 || cat == 2 || cat == 4 );
1158 h->non_zero_count_cache[scan8[n]] = coeff_count;
1163 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1165 int j= scantable[index[--coeff_count]];
1167 if( get_cabac( CC, ctx ) == 0 ) {
1168 node_ctx = coeff_abs_level_transition[0][node_ctx];
1170 block[j] = get_cabac_bypass_sign( CC, -1);
1172 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1176 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1177 node_ctx = coeff_abs_level_transition[1][node_ctx];
1179 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1183 if( coeff_abs >= 15 ) {
1185 while( get_cabac_bypass( CC ) ) {
1191 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1197 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1199 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1202 } while( coeff_count );
1203 #ifdef CABAC_ON_STACK
1204 h->cabac.range = cc.range ;
1205 h->cabac.low = cc.low ;
1206 h->cabac.bytestream= cc.bytestream;
1212 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1213 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1216 static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1217 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1221 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1223 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1225 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1226 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1230 static inline void compute_mb_neighbors(H264Context *h)
1232 MpegEncContext * const s = &h->s;
1233 const int mb_xy = h->mb_xy;
1234 h->top_mb_xy = mb_xy - s->mb_stride;
1235 h->left_mb_xy[0] = mb_xy - 1;
1237 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
1238 const int top_pair_xy = pair_xy - s->mb_stride;
1239 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1240 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1241 const int curr_mb_field_flag = MB_FIELD;
1242 const int bottom = (s->mb_y & 1);
1244 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1245 h->top_mb_xy -= s->mb_stride;
1247 if (!left_mb_field_flag == curr_mb_field_flag) {
1248 h->left_mb_xy[0] = pair_xy - 1;
1250 } else if (FIELD_PICTURE) {
1251 h->top_mb_xy -= s->mb_stride;
1257 * decodes a macroblock
1258 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1260 int ff_h264_decode_mb_cabac(H264Context *h) {
1261 MpegEncContext * const s = &h->s;
1263 int mb_type, partition_count, cbp = 0;
1264 int dct8x8_allowed= h->pps.transform_8x8_mode;
1266 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1268 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1269 if( h->slice_type_nos != FF_I_TYPE ) {
1271 /* a skipped mb needs the aff flag from the following mb */
1272 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1273 predict_field_decoding_flag(h);
1274 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1275 skip = h->next_mb_skipped;
1277 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1278 /* read skip flags */
1280 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1281 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1282 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1283 if(!h->next_mb_skipped)
1284 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1289 h->cbp_table[mb_xy] = 0;
1290 h->chroma_pred_mode_table[mb_xy] = 0;
1291 h->last_qscale_diff = 0;
1298 if( (s->mb_y&1) == 0 )
1300 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1303 h->prev_mb_skipped = 0;
1305 compute_mb_neighbors(h);
1307 if( h->slice_type_nos == FF_B_TYPE ) {
1308 mb_type = decode_cabac_mb_type_b( h );
1310 partition_count= b_mb_type_info[mb_type].partition_count;
1311 mb_type= b_mb_type_info[mb_type].type;
1314 goto decode_intra_mb;
1316 } else if( h->slice_type_nos == FF_P_TYPE ) {
1317 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1319 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1320 /* P_L0_D16x16, P_8x8 */
1321 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1323 /* P_L0_D8x16, P_L0_D16x8 */
1324 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1326 partition_count= p_mb_type_info[mb_type].partition_count;
1327 mb_type= p_mb_type_info[mb_type].type;
1329 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1330 goto decode_intra_mb;
1333 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1334 if(h->slice_type == FF_SI_TYPE && mb_type)
1336 assert(h->slice_type_nos == FF_I_TYPE);
1338 partition_count = 0;
1339 cbp= i_mb_type_info[mb_type].cbp;
1340 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1341 mb_type= i_mb_type_info[mb_type].type;
1344 mb_type |= MB_TYPE_INTERLACED;
1346 h->slice_table[ mb_xy ]= h->slice_num;
1348 if(IS_INTRA_PCM(mb_type)) {
1351 // We assume these blocks are very rare so we do not optimize it.
1352 // FIXME The two following lines get the bitstream position in the cabac
1353 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1354 ptr= h->cabac.bytestream;
1355 if(h->cabac.low&0x1) ptr--;
1357 if(h->cabac.low&0x1FF) ptr--;
1360 // The pixels are stored in the same order as levels in h->mb array.
1361 memcpy(h->mb, ptr, 256); ptr+=256;
1363 memcpy(h->mb+128, ptr, 128); ptr+=128;
1366 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1368 // All blocks are present
1369 h->cbp_table[mb_xy] = 0x1ef;
1370 h->chroma_pred_mode_table[mb_xy] = 0;
1371 // In deblocking, the quantizer is 0
1372 s->current_picture.qscale_table[mb_xy]= 0;
1373 // All coeffs are present
1374 memset(h->non_zero_count[mb_xy], 16, 32);
1375 s->current_picture.mb_type[mb_xy]= mb_type;
1376 h->last_qscale_diff = 0;
1381 h->ref_count[0] <<= 1;
1382 h->ref_count[1] <<= 1;
1385 fill_decode_caches(h, mb_type);
1387 if( IS_INTRA( mb_type ) ) {
1389 if( IS_INTRA4x4( mb_type ) ) {
1390 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
1391 mb_type |= MB_TYPE_8x8DCT;
1392 for( i = 0; i < 16; i+=4 ) {
1393 int pred = pred_intra_mode( h, i );
1394 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1395 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1398 for( i = 0; i < 16; i++ ) {
1399 int pred = pred_intra_mode( h, i );
1400 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1402 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1405 ff_h264_write_back_intra_pred_mode(h);
1406 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1408 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1409 if( h->intra16x16_pred_mode < 0 ) return -1;
1412 h->chroma_pred_mode_table[mb_xy] =
1413 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1415 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1416 if( pred_mode < 0 ) return -1;
1417 h->chroma_pred_mode= pred_mode;
1419 } else if( partition_count == 4 ) {
1420 int i, j, sub_partition_count[4], list, ref[2][4];
1422 if( h->slice_type_nos == FF_B_TYPE ) {
1423 for( i = 0; i < 4; i++ ) {
1424 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1425 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1426 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1428 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1429 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1430 ff_h264_pred_direct_motion(h, &mb_type);
1431 h->ref_cache[0][scan8[4]] =
1432 h->ref_cache[1][scan8[4]] =
1433 h->ref_cache[0][scan8[12]] =
1434 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1435 for( i = 0; i < 4; i++ )
1436 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1439 for( i = 0; i < 4; i++ ) {
1440 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1441 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1442 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1446 for( list = 0; list < h->list_count; list++ ) {
1447 for( i = 0; i < 4; i++ ) {
1448 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1449 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1450 if( h->ref_count[list] > 1 ){
1451 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1452 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1453 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1461 h->ref_cache[list][ scan8[4*i]+1 ]=
1462 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1467 dct8x8_allowed = get_dct8x8_allowed(h);
1469 for(list=0; list<h->list_count; list++){
1471 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1472 if(IS_DIRECT(h->sub_mb_type[i])){
1473 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1477 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1478 const int sub_mb_type= h->sub_mb_type[i];
1479 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1480 for(j=0; j<sub_partition_count[i]; j++){
1483 const int index= 4*i + block_width*j;
1484 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1485 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1486 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1488 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1489 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1490 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1492 if(IS_SUB_8X8(sub_mb_type)){
1494 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1496 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1499 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1501 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1502 }else if(IS_SUB_8X4(sub_mb_type)){
1503 mv_cache[ 1 ][0]= mx;
1504 mv_cache[ 1 ][1]= my;
1506 mvd_cache[ 1 ][0]= mx - mpx;
1507 mvd_cache[ 1 ][1]= my - mpy;
1508 }else if(IS_SUB_4X8(sub_mb_type)){
1509 mv_cache[ 8 ][0]= mx;
1510 mv_cache[ 8 ][1]= my;
1512 mvd_cache[ 8 ][0]= mx - mpx;
1513 mvd_cache[ 8 ][1]= my - mpy;
1515 mv_cache[ 0 ][0]= mx;
1516 mv_cache[ 0 ][1]= my;
1518 mvd_cache[ 0 ][0]= mx - mpx;
1519 mvd_cache[ 0 ][1]= my - mpy;
1522 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1523 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1524 p[0] = p[1] = p[8] = p[9] = 0;
1525 pd[0]= pd[1]= pd[8]= pd[9]= 0;
1529 } else if( IS_DIRECT(mb_type) ) {
1530 ff_h264_pred_direct_motion(h, &mb_type);
1531 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1532 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1533 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1535 int list, mx, my, i, mpx, mpy;
1536 if(IS_16X16(mb_type)){
1537 for(list=0; list<h->list_count; list++){
1538 if(IS_DIR(mb_type, 0, list)){
1540 if(h->ref_count[list] > 1){
1541 ref= decode_cabac_mb_ref(h, list, 0);
1542 if(ref >= (unsigned)h->ref_count[list]){
1543 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1548 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1550 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
1552 for(list=0; list<h->list_count; list++){
1553 if(IS_DIR(mb_type, 0, list)){
1554 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1556 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1557 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1558 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1560 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1561 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1563 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1566 else if(IS_16X8(mb_type)){
1567 for(list=0; list<h->list_count; list++){
1569 if(IS_DIR(mb_type, i, list)){
1571 if(h->ref_count[list] > 1){
1572 ref= decode_cabac_mb_ref( h, list, 8*i );
1573 if(ref >= (unsigned)h->ref_count[list]){
1574 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1579 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1581 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1584 for(list=0; list<h->list_count; list++){
1586 if(IS_DIR(mb_type, i, list)){
1587 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1588 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1589 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1590 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1592 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1593 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1595 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1596 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1601 assert(IS_8X16(mb_type));
1602 for(list=0; list<h->list_count; list++){
1604 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1606 if(h->ref_count[list] > 1){
1607 ref= decode_cabac_mb_ref( h, list, 4*i );
1608 if(ref >= (unsigned)h->ref_count[list]){
1609 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1614 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1616 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1619 for(list=0; list<h->list_count; list++){
1621 if(IS_DIR(mb_type, i, list)){
1622 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1623 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1624 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1626 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1627 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1628 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1630 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1631 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1638 if( IS_INTER( mb_type ) ) {
1639 h->chroma_pred_mode_table[mb_xy] = 0;
1640 write_back_motion( h, mb_type );
1643 if( !IS_INTRA16x16( mb_type ) ) {
1644 cbp = decode_cabac_mb_cbp_luma( h );
1646 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1649 h->cbp_table[mb_xy] = h->cbp = cbp;
1651 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1652 if( decode_cabac_mb_transform_size( h ) )
1653 mb_type |= MB_TYPE_8x8DCT;
1655 s->current_picture.mb_type[mb_xy]= mb_type;
1657 if( cbp || IS_INTRA16x16( mb_type ) ) {
1658 const uint8_t *scan, *scan8x8, *dc_scan;
1659 const uint32_t *qmul;
1661 if(IS_INTERLACED(mb_type)){
1662 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1663 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1664 dc_scan= luma_dc_field_scan;
1666 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1667 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1668 dc_scan= luma_dc_zigzag_scan;
1671 // decode_cabac_mb_dqp
1672 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1676 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1679 if(val > 102){ //prevent infinite loop
1680 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1688 val= -((val + 1)>>1);
1689 h->last_qscale_diff = val;
1691 if(((unsigned)s->qscale) > 51){
1692 if(s->qscale<0) s->qscale+= 52;
1693 else s->qscale-= 52;
1695 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1696 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1698 h->last_qscale_diff=0;
1700 if( IS_INTRA16x16( mb_type ) ) {
1702 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1703 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1706 qmul = h->dequant4_coeff[0][s->qscale];
1707 for( i = 0; i < 16; i++ ) {
1708 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1709 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1712 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1716 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1717 if( cbp & (1<<i8x8) ) {
1718 if( IS_8x8DCT(mb_type) ) {
1719 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1720 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1722 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1723 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1724 const int index = 4*i8x8 + i4x4;
1725 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1727 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1728 //STOP_TIMER("decode_residual")
1732 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1733 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1740 for( c = 0; c < 2; c++ ) {
1741 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1742 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1748 for( c = 0; c < 2; c++ ) {
1749 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1750 for( i = 0; i < 4; i++ ) {
1751 const int index = 16 + 4 * c + i;
1752 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1753 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1757 uint8_t * const nnz= &h->non_zero_count_cache[0];
1758 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1759 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1762 uint8_t * const nnz= &h->non_zero_count_cache[0];
1763 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1764 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1765 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1766 h->last_qscale_diff = 0;
1769 s->current_picture.qscale_table[mb_xy]= s->qscale;
1770 write_back_non_zero_count(h);
1773 h->ref_count[0] >>= 1;
1774 h->ref_count[1] >>= 1;