3f74818f6b966dc71bcfedcfb8a56a8bf5a87cf9
[libav.git] / libavcodec / h264_cabac.c
1 /*
2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
5 * This file is part of FFmpeg.
6 *
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.
11 *
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.
16 *
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
20 */
21
22 /**
23 * @file libavcodec/h264_cabac.c
24 * H.264 / AVC / MPEG4 part10 cabac decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28 #define CABAC 1
29
30 #include "internal.h"
31 #include "dsputil.h"
32 #include "avcodec.h"
33 #include "h264.h"
34 #include "h264data.h"
35 #include "h264_mvpred.h"
36 #include "golomb.h"
37
38 #include "cabac.h"
39 #if ARCH_X86
40 #include "x86/h264_i386.h"
41 #endif
42
43 //#undef NDEBUG
44 #include <assert.h>
45
46 /* Cabac pre state table */
47
48 static const int8_t cabac_context_init_I[460][2] =
49 {
50 /* 0 - 10 */
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 },
54
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 },
59 { 0, 0 },
60
61 /* 24- 39 */
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 },
66
67 /* 40 - 53 */
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 },
71 { 0, 0 }, { 0, 0 },
72
73 /* 54 - 59 */
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
75 { 0, 0 }, { 0, 0 },
76
77 /* 60 - 69 */
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
80 { 13, 41 }, { 3, 62 },
81
82 /* 70 -> 87 */
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 },
88
89 /* 88 -> 104 */
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 },
94 { -22, 125 },
95
96 /* 105 -> 135 */
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 },
105
106 /* 136 -> 165 */
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 },
115
116 /* 166 -> 196 */
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 },
125
126 /* 197 -> 226 */
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 },
135
136 /* 227 -> 251 */
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 },
143 { -4, 65 },
144
145 /* 252 -> 275 */
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 },
152
153 /* 276 a bit special (not used, bypass is used instead) */
154 { 0, 0 },
155
156 /* 277 -> 307 */
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 },
165
166 /* 308 -> 337 */
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 },
175
176 /* 338 -> 368 */
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 },
185
186 /* 369 -> 398 */
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 },
195
196 /* 399 -> 435 */
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 },
207
208 /* 436 -> 459 */
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 }
215 };
216
217 static const int8_t cabac_context_init_PB[3][460][2] =
218 {
219 /* i_cabac_init_idc == 0 */
220 {
221 /* 0 - 10 */
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 },
225
226 /* 11 - 23 */
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 },
230 { 17, 50 },
231
232 /* 24 - 39 */
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 },
237
238 /* 40 - 53 */
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 },
243
244 /* 54 - 59 */
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
246 { -7, 72 }, { 1, 58 },
247
248 /* 60 - 69 */
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
251 { 13, 41 }, { 3, 62 },
252
253 /* 70 - 87 */
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 },
263
264 /* 105 -> 165 */
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 },
280 { 9, 69 },
281
282 /* 166 - 226 */
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 },
298 { -9, 108 },
299
300 /* 227 - 275 */
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 },
313 { -8, 85 },
314
315 /* 276 a bit special (not used, bypass is used instead) */
316 { 0, 0 },
317
318 /* 277 - 337 */
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 },
334 { 26, 43 },
335
336 /* 338 - 398 */
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 },
352 { 11, 86 },
353
354 /* 399 - 435 */
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 },
365
366 /* 436 - 459 */
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 },
373 },
374
375 /* i_cabac_init_idc == 1 */
376 {
377 /* 0 - 10 */
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 },
381
382 /* 11 - 23 */
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 },
386 { 10, 54 },
387
388 /* 24 - 39 */
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 },
393
394 /* 40 - 53 */
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 },
399
400 /* 54 - 59 */
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
402 { -5, 72 },{ 0, 61 },
403
404 /* 60 - 69 */
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
407 { 13, 41 }, { 3, 62 },
408
409 /* 70 - 104 */
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 },
419
420 /* 105 -> 165 */
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 },
436 { 0, 89 },
437
438 /* 166 - 226 */
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 },
454 { -10, 116 },
455
456 /* 227 - 275 */
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 },
469 { -4, 78 },
470
471 /* 276 a bit special (not used, bypass is used instead) */
472 { 0, 0 },
473
474 /* 277 - 337 */
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 },
490 { 18, 50 },
491
492 /* 338 - 398 */
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 },
508 { 11, 83 },
509
510 /* 399 - 435 */
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 },
521
522 /* 436 - 459 */
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 },
529 },
530
531 /* i_cabac_init_idc == 2 */
532 {
533 /* 0 - 10 */
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 },
537
538 /* 11 - 23 */
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 },
542 { 14, 57 },
543
544 /* 24 - 39 */
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 },
549
550 /* 40 - 53 */
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 },
555
556 /* 54 - 59 */
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
558 { -7, 50 },{ 1, 60 },
559
560 /* 60 - 69 */
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
563 { 13, 41 }, { 3, 62 },
564
565 /* 70 - 104 */
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 },
575
576 /* 105 -> 165 */
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 },
592 { -22, 127 },
593
594 /* 166 - 226 */
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 },
610 { -24, 127 },
611
612 /* 227 - 275 */
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 },
625 { -10, 87 },
626
627 /* 276 a bit special (not used, bypass is used instead) */
628 { 0, 0 },
629
630 /* 277 - 337 */
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 },
646 { 25, 42 },
647
648 /* 338 - 398 */
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 },
664 { 25, 61 },
665
666 /* 399 - 435 */
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 },
677
678 /* 436 - 459 */
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 },
685 }
686 };
687
688 void ff_h264_init_cabac_states(H264Context *h) {
689 MpegEncContext * const s = &h->s;
690 int i;
691
692 /* calculate pre-state */
693 for( i= 0; i < 460; i++ ) {
694 int pre;
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 );
697 else
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 );
699
700 if( pre <= 63 )
701 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
702 else
703 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
704 }
705 }
706
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;
711
712 unsigned long ctx = 0;
713
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);
716
717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
718 }
719
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];
722 int mb_type;
723
724 if(intra_slice){
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;
728 int ctx=0;
729 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
730 ctx++;
731 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
732 ctx++;
733 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
734 return 0; /* I4x4 */
735 state += 2;
736 }else{
737 if( get_cabac_noinline( &h->cabac, state ) == 0 )
738 return 0; /* I4x4 */
739 }
740
741 if( get_cabac_terminate( &h->cabac ) )
742 return 25; /* PCM */
743
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] );
750 return mb_type;
751 }
752
753 static int decode_cabac_mb_type_b( H264Context *h ) {
754 MpegEncContext * const s = &h->s;
755
756 const int mba_xy = h->left_mb_xy[0];
757 const int mbb_xy = h->top_mb_xy;
758 int ctx = 0;
759 int bits;
760 assert(h->slice_type_nos == FF_B_TYPE);
761
762 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
763 ctx++;
764 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
765 ctx++;
766
767 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
768 return 0; /* B_Direct_16x16 */
769
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 */
772 }
773
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] );
778 if( bits < 8 )
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 */
786
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_* */
789 }
790
791 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
792 MpegEncContext * const s = &h->s;
793 int mba_xy, mbb_xy;
794 int ctx = 0;
795
796 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
797 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
798 mba_xy = mb_xy - 1;
799 if( (mb_y&1)
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;
803 if( MB_FIELD ){
804 mbb_xy = mb_xy - s->mb_stride;
805 if( !(mb_y&1)
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;
809 }else
810 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
811 }else{
812 int mb_xy = h->mb_xy;
813 mba_xy = mb_xy - 1;
814 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
815 }
816
817 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
818 ctx++;
819 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
820 ctx++;
821
822 if( h->slice_type_nos == FF_B_TYPE )
823 ctx += 13;
824 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
825 }
826
827 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
828 int mode = 0;
829
830 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
831 return pred_mode;
832
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] );
836
837 if( mode >= pred_mode )
838 return mode + 1;
839 else
840 return mode;
841 }
842
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;
846
847 int ctx = 0;
848
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 )
851 ctx++;
852
853 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
854 ctx++;
855
856 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
857 return 0;
858
859 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
860 return 1;
861 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
862 return 2;
863 else
864 return 3;
865 }
866
867 static int decode_cabac_mb_cbp_luma( H264Context *h) {
868 int cbp_b, cbp_a, ctx, cbp = 0;
869
870 cbp_a = h->left_cbp;
871 cbp_b = h->top_cbp;
872
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;
881 return cbp;
882 }
883 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
884 int ctx;
885 int cbp_a, cbp_b;
886
887 cbp_a = (h->left_cbp>>4)&0x03;
888 cbp_b = (h-> top_cbp>>4)&0x03;
889
890 ctx = 0;
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 )
894 return 0;
895
896 ctx = 4;
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] );
900 }
901 static int decode_cabac_mb_dqp( H264Context *h) {
902 int ctx= h->last_qscale_diff != 0;
903 int val = 0;
904
905 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
906 ctx= 2+(ctx>>1);
907 val++;
908 if(val > 102) //prevent infinite loop
909 return INT_MIN;
910 }
911
912 if( val&0x01 )
913 return (val + 1)>>1 ;
914 else
915 return -((val + 1)>>1);
916 }
917 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
918 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
919 return 0; /* 8x8 */
920 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
921 return 1; /* 8x4 */
922 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
923 return 2; /* 4x8 */
924 return 3; /* 4x4 */
925 }
926 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
927 int type;
928 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
929 return 0; /* B_Direct_8x8 */
930 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
931 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
932 type = 3;
933 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
934 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
935 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
936 type += 4;
937 }
938 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
939 type += get_cabac( &h->cabac, &h->cabac_state[39] );
940 return type;
941 }
942
943 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
944 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
945 }
946
947 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
948 int refa = h->ref_cache[list][scan8[n] - 1];
949 int refb = h->ref_cache[list][scan8[n] - 8];
950 int ref = 0;
951 int ctx = 0;
952
953 if( h->slice_type_nos == FF_B_TYPE) {
954 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
955 ctx++;
956 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
957 ctx += 2;
958 } else {
959 if( refa > 0 )
960 ctx++;
961 if( refb > 0 )
962 ctx += 2;
963 }
964
965 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
966 ref++;
967 ctx = (ctx>>2)+4;
968 if(ref >= 32 /*h->ref_list[list]*/){
969 return -1;
970 }
971 }
972 return ref;
973 }
974
975 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
976 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
977 abs( h->mvd_cache[list][scan8[n] - 8][l] );
978 int ctxbase = (l == 0) ? 40 : 47;
979 int mvd;
980 int ctx = (amvd>2) + (amvd>32);
981
982 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
983 return 0;
984
985 mvd= 1;
986 ctx= 3;
987 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
988 mvd++;
989 if( ctx < 6 )
990 ctx++;
991 }
992
993 if( mvd >= 9 ) {
994 int k = 3;
995 while( get_cabac_bypass( &h->cabac ) ) {
996 mvd += 1 << k;
997 k++;
998 if(k>24){
999 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
1000 return INT_MIN;
1001 }
1002 }
1003 while( k-- ) {
1004 if( get_cabac_bypass( &h->cabac ) )
1005 mvd += 1 << k;
1006 }
1007 }
1008 return get_cabac_bypass_sign( &h->cabac, -mvd );
1009 }
1010
1011 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
1012 int nza, nzb;
1013 int ctx = 0;
1014
1015 if( is_dc ) {
1016 if( cat == 0 ) {
1017 nza = h->left_cbp&0x100;
1018 nzb = h-> top_cbp&0x100;
1019 } else {
1020 nza = (h->left_cbp>>(6+idx))&0x01;
1021 nzb = (h-> top_cbp>>(6+idx))&0x01;
1022 }
1023 } else {
1024 assert(cat == 1 || cat == 2 || cat == 4);
1025 nza = h->non_zero_count_cache[scan8[idx] - 1];
1026 nzb = h->non_zero_count_cache[scan8[idx] - 8];
1027 }
1028
1029 if( nza > 0 )
1030 ctx++;
1031
1032 if( nzb > 0 )
1033 ctx += 2;
1034
1035 return ctx + 4 * cat;
1036 }
1037
1038 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
1039 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1040 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1041 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1042 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1043 };
1044
1045 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 ) {
1046 static const int significant_coeff_flag_offset[2][6] = {
1047 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1048 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1049 };
1050 static const int last_coeff_flag_offset[2][6] = {
1051 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1052 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1053 };
1054 static const int coeff_abs_level_m1_offset[6] = {
1055 227+0, 227+10, 227+20, 227+30, 227+39, 426
1056 };
1057 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1058 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1059 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1060 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1061 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1062 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1063 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1064 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1065 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1066 };
1067 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1068 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1069 * map node ctx => cabac ctx for level=1 */
1070 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1071 /* map node ctx => cabac ctx for level>1 */
1072 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1073 static const uint8_t coeff_abs_level_transition[2][8] = {
1074 /* update node ctx after decoding a level=1 */
1075 { 1, 2, 3, 3, 4, 5, 6, 7 },
1076 /* update node ctx after decoding a level>1 */
1077 { 4, 4, 4, 4, 5, 6, 7, 7 }
1078 };
1079
1080 int index[64];
1081
1082 int av_unused last;
1083 int coeff_count = 0;
1084 int node_ctx = 0;
1085
1086 uint8_t *significant_coeff_ctx_base;
1087 uint8_t *last_coeff_ctx_base;
1088 uint8_t *abs_level_m1_ctx_base;
1089
1090 #if !ARCH_X86
1091 #define CABAC_ON_STACK
1092 #endif
1093 #ifdef CABAC_ON_STACK
1094 #define CC &cc
1095 CABACContext cc;
1096 cc.range = h->cabac.range;
1097 cc.low = h->cabac.low;
1098 cc.bytestream= h->cabac.bytestream;
1099 #else
1100 #define CC &h->cabac
1101 #endif
1102
1103
1104 /* cat: 0-> DC 16x16 n = 0
1105 * 1-> AC 16x16 n = luma4x4idx
1106 * 2-> Luma4x4 n = luma4x4idx
1107 * 3-> DC Chroma n = iCbCr
1108 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1109 * 5-> Luma8x8 n = 4 * luma8x8idx
1110 */
1111
1112 /* read coded block flag */
1113 if( is_dc || cat != 5 ) {
1114 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1115 if( !is_dc )
1116 h->non_zero_count_cache[scan8[n]] = 0;
1117
1118 #ifdef CABAC_ON_STACK
1119 h->cabac.range = cc.range ;
1120 h->cabac.low = cc.low ;
1121 h->cabac.bytestream= cc.bytestream;
1122 #endif
1123 return;
1124 }
1125 }
1126
1127 significant_coeff_ctx_base = h->cabac_state
1128 + significant_coeff_flag_offset[MB_FIELD][cat];
1129 last_coeff_ctx_base = h->cabac_state
1130 + last_coeff_flag_offset[MB_FIELD][cat];
1131 abs_level_m1_ctx_base = h->cabac_state
1132 + coeff_abs_level_m1_offset[cat];
1133
1134 if( !is_dc && cat == 5 ) {
1135 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1136 for(last= 0; last < coefs; last++) { \
1137 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1138 if( get_cabac( CC, sig_ctx )) { \
1139 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1140 index[coeff_count++] = last; \
1141 if( get_cabac( CC, last_ctx ) ) { \
1142 last= max_coeff; \
1143 break; \
1144 } \
1145 } \
1146 }\
1147 if( last == max_coeff -1 ) {\
1148 index[coeff_count++] = last;\
1149 }
1150 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1151 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1152 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1153 } else {
1154 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1155 #else
1156 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1157 } else {
1158 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1159 #endif
1160 }
1161 assert(coeff_count > 0);
1162
1163 if( is_dc ) {
1164 if( cat == 0 )
1165 h->cbp_table[h->mb_xy] |= 0x100;
1166 else
1167 h->cbp_table[h->mb_xy] |= 0x40 << n;
1168 } else {
1169 if( cat == 5 )
1170 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1171 else {
1172 assert( cat == 1 || cat == 2 || cat == 4 );
1173 h->non_zero_count_cache[scan8[n]] = coeff_count;
1174 }
1175 }
1176
1177 do {
1178 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1179
1180 int j= scantable[index[--coeff_count]];
1181
1182 if( get_cabac( CC, ctx ) == 0 ) {
1183 node_ctx = coeff_abs_level_transition[0][node_ctx];
1184 if( is_dc ) {
1185 block[j] = get_cabac_bypass_sign( CC, -1);
1186 }else{
1187 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1188 }
1189 } else {
1190 int coeff_abs = 2;
1191 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1192 node_ctx = coeff_abs_level_transition[1][node_ctx];
1193
1194 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1195 coeff_abs++;
1196 }
1197
1198 if( coeff_abs >= 15 ) {
1199 int j = 0;
1200 while( get_cabac_bypass( CC ) ) {
1201 j++;
1202 }
1203
1204 coeff_abs=1;
1205 while( j-- ) {
1206 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1207 }
1208 coeff_abs+= 14;
1209 }
1210
1211 if( is_dc ) {
1212 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1213 }else{
1214 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1215 }
1216 }
1217 } while( coeff_count );
1218 #ifdef CABAC_ON_STACK
1219 h->cabac.range = cc.range ;
1220 h->cabac.low = cc.low ;
1221 h->cabac.bytestream= cc.bytestream;
1222 #endif
1223
1224 }
1225
1226 #if !CONFIG_SMALL
1227 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 ) {
1228 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1229 }
1230
1231 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 ) {
1232 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1233 }
1234 #endif
1235
1236 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1237 #if CONFIG_SMALL
1238 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1239 #else
1240 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1241 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1242 #endif
1243 }
1244
1245 static inline void compute_mb_neighbors(H264Context *h)
1246 {
1247 MpegEncContext * const s = &h->s;
1248 const int mb_xy = h->mb_xy;
1249 h->top_mb_xy = mb_xy - s->mb_stride;
1250 h->left_mb_xy[0] = mb_xy - 1;
1251 if(FRAME_MBAFF){
1252 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
1253 const int top_pair_xy = pair_xy - s->mb_stride;
1254 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1255 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1256 const int curr_mb_field_flag = MB_FIELD;
1257 const int bottom = (s->mb_y & 1);
1258
1259 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1260 h->top_mb_xy -= s->mb_stride;
1261 }
1262 if (!left_mb_field_flag == curr_mb_field_flag) {
1263 h->left_mb_xy[0] = pair_xy - 1;
1264 }
1265 } else if (FIELD_PICTURE) {
1266 h->top_mb_xy -= s->mb_stride;
1267 }
1268 return;
1269 }
1270
1271 /**
1272 * decodes a macroblock
1273 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1274 */
1275 int ff_h264_decode_mb_cabac(H264Context *h) {
1276 MpegEncContext * const s = &h->s;
1277 int mb_xy;
1278 int mb_type, partition_count, cbp = 0;
1279 int dct8x8_allowed= h->pps.transform_8x8_mode;
1280
1281 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1282
1283 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1284 if( h->slice_type_nos != FF_I_TYPE ) {
1285 int skip;
1286 /* a skipped mb needs the aff flag from the following mb */
1287 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1288 predict_field_decoding_flag(h);
1289 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1290 skip = h->next_mb_skipped;
1291 else
1292 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1293 /* read skip flags */
1294 if( skip ) {
1295 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1296 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1297 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1298 if(!h->next_mb_skipped)
1299 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1300 }
1301
1302 decode_mb_skip(h);
1303
1304 h->cbp_table[mb_xy] = 0;
1305 h->chroma_pred_mode_table[mb_xy] = 0;
1306 h->last_qscale_diff = 0;
1307
1308 return 0;
1309
1310 }
1311 }
1312 if(FRAME_MBAFF){
1313 if( (s->mb_y&1) == 0 )
1314 h->mb_mbaff =
1315 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1316 }
1317
1318 h->prev_mb_skipped = 0;
1319
1320 compute_mb_neighbors(h);
1321
1322 if( h->slice_type_nos == FF_B_TYPE ) {
1323 mb_type = decode_cabac_mb_type_b( h );
1324 if( mb_type < 23 ){
1325 partition_count= b_mb_type_info[mb_type].partition_count;
1326 mb_type= b_mb_type_info[mb_type].type;
1327 }else{
1328 mb_type -= 23;
1329 goto decode_intra_mb;
1330 }
1331 } else if( h->slice_type_nos == FF_P_TYPE ) {
1332 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1333 /* P-type */
1334 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1335 /* P_L0_D16x16, P_8x8 */
1336 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1337 } else {
1338 /* P_L0_D8x16, P_L0_D16x8 */
1339 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1340 }
1341 partition_count= p_mb_type_info[mb_type].partition_count;
1342 mb_type= p_mb_type_info[mb_type].type;
1343 } else {
1344 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1345 goto decode_intra_mb;
1346 }
1347 } else {
1348 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1349 if(h->slice_type == FF_SI_TYPE && mb_type)
1350 mb_type--;
1351 assert(h->slice_type_nos == FF_I_TYPE);
1352 decode_intra_mb:
1353 partition_count = 0;
1354 cbp= i_mb_type_info[mb_type].cbp;
1355 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1356 mb_type= i_mb_type_info[mb_type].type;
1357 }
1358 if(MB_FIELD)
1359 mb_type |= MB_TYPE_INTERLACED;
1360
1361 h->slice_table[ mb_xy ]= h->slice_num;
1362
1363 if(IS_INTRA_PCM(mb_type)) {
1364 const uint8_t *ptr;
1365
1366 // We assume these blocks are very rare so we do not optimize it.
1367 // FIXME The two following lines get the bitstream position in the cabac
1368 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1369 ptr= h->cabac.bytestream;
1370 if(h->cabac.low&0x1) ptr--;
1371 if(CABAC_BITS==16){
1372 if(h->cabac.low&0x1FF) ptr--;
1373 }
1374
1375 // The pixels are stored in the same order as levels in h->mb array.
1376 memcpy(h->mb, ptr, 256); ptr+=256;
1377 if(CHROMA){
1378 memcpy(h->mb+128, ptr, 128); ptr+=128;
1379 }
1380
1381 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1382
1383 // All blocks are present
1384 h->cbp_table[mb_xy] = 0x1ef;
1385 h->chroma_pred_mode_table[mb_xy] = 0;
1386 // In deblocking, the quantizer is 0
1387 s->current_picture.qscale_table[mb_xy]= 0;
1388 // All coeffs are present
1389 memset(h->non_zero_count[mb_xy], 16, 32);
1390 s->current_picture.mb_type[mb_xy]= mb_type;
1391 h->last_qscale_diff = 0;
1392 return 0;
1393 }
1394
1395 if(MB_MBAFF){
1396 h->ref_count[0] <<= 1;
1397 h->ref_count[1] <<= 1;
1398 }
1399
1400 fill_decode_caches(h, mb_type);
1401
1402 if( IS_INTRA( mb_type ) ) {
1403 int i, pred_mode;
1404 if( IS_INTRA4x4( mb_type ) ) {
1405 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
1406 mb_type |= MB_TYPE_8x8DCT;
1407 for( i = 0; i < 16; i+=4 ) {
1408 int pred = pred_intra_mode( h, i );
1409 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1410 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1411 }
1412 } else {
1413 for( i = 0; i < 16; i++ ) {
1414 int pred = pred_intra_mode( h, i );
1415 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1416
1417 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1418 }
1419 }
1420 ff_h264_write_back_intra_pred_mode(h);
1421 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1422 } else {
1423 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1424 if( h->intra16x16_pred_mode < 0 ) return -1;
1425 }
1426 if(CHROMA){
1427 h->chroma_pred_mode_table[mb_xy] =
1428 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1429
1430 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1431 if( pred_mode < 0 ) return -1;
1432 h->chroma_pred_mode= pred_mode;
1433 }
1434 } else if( partition_count == 4 ) {
1435 int i, j, sub_partition_count[4], list, ref[2][4];
1436
1437 if( h->slice_type_nos == FF_B_TYPE ) {
1438 for( i = 0; i < 4; i++ ) {
1439 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1440 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1441 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1442 }
1443 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1444 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1445 ff_h264_pred_direct_motion(h, &mb_type);
1446 h->ref_cache[0][scan8[4]] =
1447 h->ref_cache[1][scan8[4]] =
1448 h->ref_cache[0][scan8[12]] =
1449 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1450 for( i = 0; i < 4; i++ )
1451 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1452 }
1453 } else {
1454 for( i = 0; i < 4; i++ ) {
1455 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1456 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1457 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1458 }
1459 }
1460
1461 for( list = 0; list < h->list_count; list++ ) {
1462 for( i = 0; i < 4; i++ ) {
1463 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1464 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1465 if( h->ref_count[list] > 1 ){
1466 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1467 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1468 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1469 return -1;
1470 }
1471 }else
1472 ref[list][i] = 0;
1473 } else {
1474 ref[list][i] = -1;
1475 }
1476 h->ref_cache[list][ scan8[4*i]+1 ]=
1477 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1478 }
1479 }
1480
1481 if(dct8x8_allowed)
1482 dct8x8_allowed = get_dct8x8_allowed(h);
1483
1484 for(list=0; list<h->list_count; list++){
1485 for(i=0; i<4; i++){
1486 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1487 if(IS_DIRECT(h->sub_mb_type[i])){
1488 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1489 continue;
1490 }
1491
1492 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1493 const int sub_mb_type= h->sub_mb_type[i];
1494 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1495 for(j=0; j<sub_partition_count[i]; j++){
1496 int mpx, mpy;
1497 int mx, my;
1498 const int index= 4*i + block_width*j;
1499 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1500 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1501 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1502
1503 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1504 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1505 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1506
1507 if(IS_SUB_8X8(sub_mb_type)){
1508 mv_cache[ 1 ][0]=
1509 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1510 mv_cache[ 1 ][1]=
1511 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1512
1513 mvd_cache[ 1 ][0]=
1514 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1515 mvd_cache[ 1 ][1]=
1516 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1517 }else if(IS_SUB_8X4(sub_mb_type)){
1518 mv_cache[ 1 ][0]= mx;
1519 mv_cache[ 1 ][1]= my;
1520
1521 mvd_cache[ 1 ][0]= mx - mpx;
1522 mvd_cache[ 1 ][1]= my - mpy;
1523 }else if(IS_SUB_4X8(sub_mb_type)){
1524 mv_cache[ 8 ][0]= mx;
1525 mv_cache[ 8 ][1]= my;
1526
1527 mvd_cache[ 8 ][0]= mx - mpx;
1528 mvd_cache[ 8 ][1]= my - mpy;
1529 }
1530 mv_cache[ 0 ][0]= mx;
1531 mv_cache[ 0 ][1]= my;
1532
1533 mvd_cache[ 0 ][0]= mx - mpx;
1534 mvd_cache[ 0 ][1]= my - mpy;
1535 }
1536 }else{
1537 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1538 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1539 p[0] = p[1] = p[8] = p[9] = 0;
1540 pd[0]= pd[1]= pd[8]= pd[9]= 0;
1541 }
1542 }
1543 }
1544 } else if( IS_DIRECT(mb_type) ) {
1545 ff_h264_pred_direct_motion(h, &mb_type);
1546 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1547 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1548 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1549 } else {
1550 int list, mx, my, i, mpx, mpy;
1551 if(IS_16X16(mb_type)){
1552 for(list=0; list<h->list_count; list++){
1553 if(IS_DIR(mb_type, 0, list)){
1554 int ref;
1555 if(h->ref_count[list] > 1){
1556 ref= decode_cabac_mb_ref(h, list, 0);
1557 if(ref >= (unsigned)h->ref_count[list]){
1558 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1559 return -1;
1560 }
1561 }else
1562 ref=0;
1563 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1564 }else
1565 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
1566 }
1567 for(list=0; list<h->list_count; list++){
1568 if(IS_DIR(mb_type, 0, list)){
1569 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1570
1571 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1572 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1573 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1574
1575 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1576 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1577 }else
1578 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1579 }
1580 }
1581 else if(IS_16X8(mb_type)){
1582 for(list=0; list<h->list_count; list++){
1583 for(i=0; i<2; i++){
1584 if(IS_DIR(mb_type, i, list)){
1585 int ref;
1586 if(h->ref_count[list] > 1){
1587 ref= decode_cabac_mb_ref( h, list, 8*i );
1588 if(ref >= (unsigned)h->ref_count[list]){
1589 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1590 return -1;
1591 }
1592 }else
1593 ref=0;
1594 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1595 }else
1596 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1597 }
1598 }
1599 for(list=0; list<h->list_count; list++){
1600 for(i=0; i<2; i++){
1601 if(IS_DIR(mb_type, i, list)){
1602 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1603 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1604 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1605 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1606
1607 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1608 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1609 }else{
1610 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1611 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1612 }
1613 }
1614 }
1615 }else{
1616 assert(IS_8X16(mb_type));
1617 for(list=0; list<h->list_count; list++){
1618 for(i=0; i<2; i++){
1619 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1620 int ref;
1621 if(h->ref_count[list] > 1){
1622 ref= decode_cabac_mb_ref( h, list, 4*i );
1623 if(ref >= (unsigned)h->ref_count[list]){
1624 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1625 return -1;
1626 }
1627 }else
1628 ref=0;
1629 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1630 }else
1631 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1632 }
1633 }
1634 for(list=0; list<h->list_count; list++){
1635 for(i=0; i<2; i++){
1636 if(IS_DIR(mb_type, i, list)){
1637 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1638 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1639 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1640
1641 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1642 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1643 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1644 }else{
1645 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1646 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1647 }
1648 }
1649 }
1650 }
1651 }
1652
1653 if( IS_INTER( mb_type ) ) {
1654 h->chroma_pred_mode_table[mb_xy] = 0;
1655 write_back_motion( h, mb_type );
1656 }
1657
1658 if( !IS_INTRA16x16( mb_type ) ) {
1659 cbp = decode_cabac_mb_cbp_luma( h );
1660 if(CHROMA)
1661 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1662 }
1663
1664 h->cbp_table[mb_xy] = h->cbp = cbp;
1665
1666 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1667 if( decode_cabac_mb_transform_size( h ) )
1668 mb_type |= MB_TYPE_8x8DCT;
1669 }
1670 s->current_picture.mb_type[mb_xy]= mb_type;
1671
1672 if( cbp || IS_INTRA16x16( mb_type ) ) {
1673 const uint8_t *scan, *scan8x8, *dc_scan;
1674 const uint32_t *qmul;
1675 int dqp;
1676
1677 if(IS_INTERLACED(mb_type)){
1678 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1679 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1680 dc_scan= luma_dc_field_scan;
1681 }else{
1682 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1683 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1684 dc_scan= luma_dc_zigzag_scan;
1685 }
1686
1687 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
1688 if( dqp == INT_MIN ){
1689 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1690 return -1;
1691 }
1692 s->qscale += dqp;
1693 if(((unsigned)s->qscale) > 51){
1694 if(s->qscale<0) s->qscale+= 52;
1695 else s->qscale-= 52;
1696 }
1697 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1698 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1699
1700 if( IS_INTRA16x16( mb_type ) ) {
1701 int i;
1702 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1703 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1704
1705 if( cbp&15 ) {
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);
1710 }
1711 } else {
1712 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1713 }
1714 } else {
1715 int i8x8, i4x4;
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);
1721 } else {
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 );
1726 //START_TIMER
1727 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1728 //STOP_TIMER("decode_residual")
1729 }
1730 }
1731 } else {
1732 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1733 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1734 }
1735 }
1736 }
1737
1738 if( cbp&0x30 ){
1739 int c;
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);
1743 }
1744 }
1745
1746 if( cbp&0x20 ) {
1747 int c, i;
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);
1754 }
1755 }
1756 } else {
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;
1760 }
1761 } else {
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;
1767 }
1768
1769 s->current_picture.qscale_table[mb_xy]= s->qscale;
1770 write_back_non_zero_count(h);
1771
1772 if(MB_MBAFF){
1773 h->ref_count[0] >>= 1;
1774 h->ref_count[1] >>= 1;
1775 }
1776
1777 return 0;
1778 }