Merge the single line function decode_cabac_mb_transform_size()
[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
902 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
903 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
904 return 0; /* 8x8 */
905 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
906 return 1; /* 8x4 */
907 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
908 return 2; /* 4x8 */
909 return 3; /* 4x4 */
910 }
911 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
912 int type;
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 */
917 type = 3;
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 */
921 type += 4;
922 }
923 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
924 type += get_cabac( &h->cabac, &h->cabac_state[39] );
925 return type;
926 }
927
928 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
929 int refa = h->ref_cache[list][scan8[n] - 1];
930 int refb = h->ref_cache[list][scan8[n] - 8];
931 int ref = 0;
932 int ctx = 0;
933
934 if( h->slice_type_nos == FF_B_TYPE) {
935 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
936 ctx++;
937 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
938 ctx += 2;
939 } else {
940 if( refa > 0 )
941 ctx++;
942 if( refb > 0 )
943 ctx += 2;
944 }
945
946 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
947 ref++;
948 ctx = (ctx>>2)+4;
949 if(ref >= 32 /*h->ref_list[list]*/){
950 return -1;
951 }
952 }
953 return ref;
954 }
955
956 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
957 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
958 abs( h->mvd_cache[list][scan8[n] - 8][l] );
959 int ctxbase = (l == 0) ? 40 : 47;
960 int mvd;
961 int ctx = (amvd>2) + (amvd>32);
962
963 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
964 return 0;
965
966 mvd= 1;
967 ctx= 3;
968 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
969 mvd++;
970 if( ctx < 6 )
971 ctx++;
972 }
973
974 if( mvd >= 9 ) {
975 int k = 3;
976 while( get_cabac_bypass( &h->cabac ) ) {
977 mvd += 1 << k;
978 k++;
979 if(k>24){
980 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
981 return INT_MIN;
982 }
983 }
984 while( k-- ) {
985 if( get_cabac_bypass( &h->cabac ) )
986 mvd += 1 << k;
987 }
988 }
989 return get_cabac_bypass_sign( &h->cabac, -mvd );
990 }
991
992 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
993 int nza, nzb;
994 int ctx = 0;
995
996 if( is_dc ) {
997 if( cat == 0 ) {
998 nza = h->left_cbp&0x100;
999 nzb = h-> top_cbp&0x100;
1000 } else {
1001 nza = (h->left_cbp>>(6+idx))&0x01;
1002 nzb = (h-> top_cbp>>(6+idx))&0x01;
1003 }
1004 } else {
1005 assert(cat == 1 || cat == 2 || cat == 4);
1006 nza = h->non_zero_count_cache[scan8[idx] - 1];
1007 nzb = h->non_zero_count_cache[scan8[idx] - 8];
1008 }
1009
1010 if( nza > 0 )
1011 ctx++;
1012
1013 if( nzb > 0 )
1014 ctx += 2;
1015
1016 return ctx + 4 * cat;
1017 }
1018
1019 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
1020 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1021 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1022 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1023 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1024 };
1025
1026 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 ) {
1027 static const int significant_coeff_flag_offset[2][6] = {
1028 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1029 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1030 };
1031 static const int last_coeff_flag_offset[2][6] = {
1032 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1033 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1034 };
1035 static const int coeff_abs_level_m1_offset[6] = {
1036 227+0, 227+10, 227+20, 227+30, 227+39, 426
1037 };
1038 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1039 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1040 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1041 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1042 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1043 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1044 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1045 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1046 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1047 };
1048 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1049 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1050 * map node ctx => cabac ctx for level=1 */
1051 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1052 /* map node ctx => cabac ctx for level>1 */
1053 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1054 static const uint8_t coeff_abs_level_transition[2][8] = {
1055 /* update node ctx after decoding a level=1 */
1056 { 1, 2, 3, 3, 4, 5, 6, 7 },
1057 /* update node ctx after decoding a level>1 */
1058 { 4, 4, 4, 4, 5, 6, 7, 7 }
1059 };
1060
1061 int index[64];
1062
1063 int av_unused last;
1064 int coeff_count = 0;
1065 int node_ctx = 0;
1066
1067 uint8_t *significant_coeff_ctx_base;
1068 uint8_t *last_coeff_ctx_base;
1069 uint8_t *abs_level_m1_ctx_base;
1070
1071 #if !ARCH_X86
1072 #define CABAC_ON_STACK
1073 #endif
1074 #ifdef CABAC_ON_STACK
1075 #define CC &cc
1076 CABACContext cc;
1077 cc.range = h->cabac.range;
1078 cc.low = h->cabac.low;
1079 cc.bytestream= h->cabac.bytestream;
1080 #else
1081 #define CC &h->cabac
1082 #endif
1083
1084
1085 /* cat: 0-> DC 16x16 n = 0
1086 * 1-> AC 16x16 n = luma4x4idx
1087 * 2-> Luma4x4 n = luma4x4idx
1088 * 3-> DC Chroma n = iCbCr
1089 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1090 * 5-> Luma8x8 n = 4 * luma8x8idx
1091 */
1092
1093 /* read coded block flag */
1094 if( is_dc || cat != 5 ) {
1095 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1096 if( !is_dc )
1097 h->non_zero_count_cache[scan8[n]] = 0;
1098
1099 #ifdef CABAC_ON_STACK
1100 h->cabac.range = cc.range ;
1101 h->cabac.low = cc.low ;
1102 h->cabac.bytestream= cc.bytestream;
1103 #endif
1104 return;
1105 }
1106 }
1107
1108 significant_coeff_ctx_base = h->cabac_state
1109 + significant_coeff_flag_offset[MB_FIELD][cat];
1110 last_coeff_ctx_base = h->cabac_state
1111 + last_coeff_flag_offset[MB_FIELD][cat];
1112 abs_level_m1_ctx_base = h->cabac_state
1113 + coeff_abs_level_m1_offset[cat];
1114
1115 if( !is_dc && cat == 5 ) {
1116 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1117 for(last= 0; last < coefs; last++) { \
1118 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1119 if( get_cabac( CC, sig_ctx )) { \
1120 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1121 index[coeff_count++] = last; \
1122 if( get_cabac( CC, last_ctx ) ) { \
1123 last= max_coeff; \
1124 break; \
1125 } \
1126 } \
1127 }\
1128 if( last == max_coeff -1 ) {\
1129 index[coeff_count++] = last;\
1130 }
1131 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1132 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1133 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1134 } else {
1135 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1136 #else
1137 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1138 } else {
1139 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1140 #endif
1141 }
1142 assert(coeff_count > 0);
1143
1144 if( is_dc ) {
1145 if( cat == 0 )
1146 h->cbp_table[h->mb_xy] |= 0x100;
1147 else
1148 h->cbp_table[h->mb_xy] |= 0x40 << n;
1149 } else {
1150 if( cat == 5 )
1151 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1152 else {
1153 assert( cat == 1 || cat == 2 || cat == 4 );
1154 h->non_zero_count_cache[scan8[n]] = coeff_count;
1155 }
1156 }
1157
1158 do {
1159 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1160
1161 int j= scantable[index[--coeff_count]];
1162
1163 if( get_cabac( CC, ctx ) == 0 ) {
1164 node_ctx = coeff_abs_level_transition[0][node_ctx];
1165 if( is_dc ) {
1166 block[j] = get_cabac_bypass_sign( CC, -1);
1167 }else{
1168 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1169 }
1170 } else {
1171 int coeff_abs = 2;
1172 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1173 node_ctx = coeff_abs_level_transition[1][node_ctx];
1174
1175 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1176 coeff_abs++;
1177 }
1178
1179 if( coeff_abs >= 15 ) {
1180 int j = 0;
1181 while( get_cabac_bypass( CC ) ) {
1182 j++;
1183 }
1184
1185 coeff_abs=1;
1186 while( j-- ) {
1187 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1188 }
1189 coeff_abs+= 14;
1190 }
1191
1192 if( is_dc ) {
1193 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1194 }else{
1195 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1196 }
1197 }
1198 } while( coeff_count );
1199 #ifdef CABAC_ON_STACK
1200 h->cabac.range = cc.range ;
1201 h->cabac.low = cc.low ;
1202 h->cabac.bytestream= cc.bytestream;
1203 #endif
1204
1205 }
1206
1207 #if !CONFIG_SMALL
1208 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 ) {
1209 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1210 }
1211
1212 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 ) {
1213 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1214 }
1215 #endif
1216
1217 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1218 #if CONFIG_SMALL
1219 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1220 #else
1221 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1222 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1223 #endif
1224 }
1225
1226 static inline void compute_mb_neighbors(H264Context *h)
1227 {
1228 MpegEncContext * const s = &h->s;
1229 const int mb_xy = h->mb_xy;
1230 h->top_mb_xy = mb_xy - s->mb_stride;
1231 h->left_mb_xy[0] = mb_xy - 1;
1232 if(FRAME_MBAFF){
1233 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
1234 const int top_pair_xy = pair_xy - s->mb_stride;
1235 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1236 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1237 const int curr_mb_field_flag = MB_FIELD;
1238 const int bottom = (s->mb_y & 1);
1239
1240 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1241 h->top_mb_xy -= s->mb_stride;
1242 }
1243 if (!left_mb_field_flag == curr_mb_field_flag) {
1244 h->left_mb_xy[0] = pair_xy - 1;
1245 }
1246 } else if (FIELD_PICTURE) {
1247 h->top_mb_xy -= s->mb_stride;
1248 }
1249 return;
1250 }
1251
1252 /**
1253 * decodes a macroblock
1254 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1255 */
1256 int ff_h264_decode_mb_cabac(H264Context *h) {
1257 MpegEncContext * const s = &h->s;
1258 int mb_xy;
1259 int mb_type, partition_count, cbp = 0;
1260 int dct8x8_allowed= h->pps.transform_8x8_mode;
1261
1262 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1263
1264 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1265 if( h->slice_type_nos != FF_I_TYPE ) {
1266 int skip;
1267 /* a skipped mb needs the aff flag from the following mb */
1268 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1269 predict_field_decoding_flag(h);
1270 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1271 skip = h->next_mb_skipped;
1272 else
1273 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1274 /* read skip flags */
1275 if( skip ) {
1276 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1277 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1278 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1279 if(!h->next_mb_skipped)
1280 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1281 }
1282
1283 decode_mb_skip(h);
1284
1285 h->cbp_table[mb_xy] = 0;
1286 h->chroma_pred_mode_table[mb_xy] = 0;
1287 h->last_qscale_diff = 0;
1288
1289 return 0;
1290
1291 }
1292 }
1293 if(FRAME_MBAFF){
1294 if( (s->mb_y&1) == 0 )
1295 h->mb_mbaff =
1296 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1297 }
1298
1299 h->prev_mb_skipped = 0;
1300
1301 compute_mb_neighbors(h);
1302
1303 if( h->slice_type_nos == FF_B_TYPE ) {
1304 mb_type = decode_cabac_mb_type_b( h );
1305 if( mb_type < 23 ){
1306 partition_count= b_mb_type_info[mb_type].partition_count;
1307 mb_type= b_mb_type_info[mb_type].type;
1308 }else{
1309 mb_type -= 23;
1310 goto decode_intra_mb;
1311 }
1312 } else if( h->slice_type_nos == FF_P_TYPE ) {
1313 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1314 /* P-type */
1315 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1316 /* P_L0_D16x16, P_8x8 */
1317 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1318 } else {
1319 /* P_L0_D8x16, P_L0_D16x8 */
1320 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1321 }
1322 partition_count= p_mb_type_info[mb_type].partition_count;
1323 mb_type= p_mb_type_info[mb_type].type;
1324 } else {
1325 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1326 goto decode_intra_mb;
1327 }
1328 } else {
1329 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1330 if(h->slice_type == FF_SI_TYPE && mb_type)
1331 mb_type--;
1332 assert(h->slice_type_nos == FF_I_TYPE);
1333 decode_intra_mb:
1334 partition_count = 0;
1335 cbp= i_mb_type_info[mb_type].cbp;
1336 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1337 mb_type= i_mb_type_info[mb_type].type;
1338 }
1339 if(MB_FIELD)
1340 mb_type |= MB_TYPE_INTERLACED;
1341
1342 h->slice_table[ mb_xy ]= h->slice_num;
1343
1344 if(IS_INTRA_PCM(mb_type)) {
1345 const uint8_t *ptr;
1346
1347 // We assume these blocks are very rare so we do not optimize it.
1348 // FIXME The two following lines get the bitstream position in the cabac
1349 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1350 ptr= h->cabac.bytestream;
1351 if(h->cabac.low&0x1) ptr--;
1352 if(CABAC_BITS==16){
1353 if(h->cabac.low&0x1FF) ptr--;
1354 }
1355
1356 // The pixels are stored in the same order as levels in h->mb array.
1357 memcpy(h->mb, ptr, 256); ptr+=256;
1358 if(CHROMA){
1359 memcpy(h->mb+128, ptr, 128); ptr+=128;
1360 }
1361
1362 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1363
1364 // All blocks are present
1365 h->cbp_table[mb_xy] = 0x1ef;
1366 h->chroma_pred_mode_table[mb_xy] = 0;
1367 // In deblocking, the quantizer is 0
1368 s->current_picture.qscale_table[mb_xy]= 0;
1369 // All coeffs are present
1370 memset(h->non_zero_count[mb_xy], 16, 32);
1371 s->current_picture.mb_type[mb_xy]= mb_type;
1372 h->last_qscale_diff = 0;
1373 return 0;
1374 }
1375
1376 if(MB_MBAFF){
1377 h->ref_count[0] <<= 1;
1378 h->ref_count[1] <<= 1;
1379 }
1380
1381 fill_decode_caches(h, mb_type);
1382
1383 if( IS_INTRA( mb_type ) ) {
1384 int i, pred_mode;
1385 if( IS_INTRA4x4( mb_type ) ) {
1386 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1387 mb_type |= MB_TYPE_8x8DCT;
1388 for( i = 0; i < 16; i+=4 ) {
1389 int pred = pred_intra_mode( h, i );
1390 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1391 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1392 }
1393 } else {
1394 for( i = 0; i < 16; i++ ) {
1395 int pred = pred_intra_mode( h, i );
1396 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1397
1398 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1399 }
1400 }
1401 ff_h264_write_back_intra_pred_mode(h);
1402 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1403 } else {
1404 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1405 if( h->intra16x16_pred_mode < 0 ) return -1;
1406 }
1407 if(CHROMA){
1408 h->chroma_pred_mode_table[mb_xy] =
1409 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1410
1411 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1412 if( pred_mode < 0 ) return -1;
1413 h->chroma_pred_mode= pred_mode;
1414 }
1415 } else if( partition_count == 4 ) {
1416 int i, j, sub_partition_count[4], list, ref[2][4];
1417
1418 if( h->slice_type_nos == FF_B_TYPE ) {
1419 for( i = 0; i < 4; i++ ) {
1420 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1421 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1422 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1423 }
1424 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1425 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1426 ff_h264_pred_direct_motion(h, &mb_type);
1427 h->ref_cache[0][scan8[4]] =
1428 h->ref_cache[1][scan8[4]] =
1429 h->ref_cache[0][scan8[12]] =
1430 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1431 for( i = 0; i < 4; i++ )
1432 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1433 }
1434 } else {
1435 for( i = 0; i < 4; i++ ) {
1436 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1437 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1438 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1439 }
1440 }
1441
1442 for( list = 0; list < h->list_count; list++ ) {
1443 for( i = 0; i < 4; i++ ) {
1444 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1445 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1446 if( h->ref_count[list] > 1 ){
1447 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1448 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1449 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1450 return -1;
1451 }
1452 }else
1453 ref[list][i] = 0;
1454 } else {
1455 ref[list][i] = -1;
1456 }
1457 h->ref_cache[list][ scan8[4*i]+1 ]=
1458 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1459 }
1460 }
1461
1462 if(dct8x8_allowed)
1463 dct8x8_allowed = get_dct8x8_allowed(h);
1464
1465 for(list=0; list<h->list_count; list++){
1466 for(i=0; i<4; i++){
1467 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1468 if(IS_DIRECT(h->sub_mb_type[i])){
1469 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1470 continue;
1471 }
1472
1473 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1474 const int sub_mb_type= h->sub_mb_type[i];
1475 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1476 for(j=0; j<sub_partition_count[i]; j++){
1477 int mpx, mpy;
1478 int mx, my;
1479 const int index= 4*i + block_width*j;
1480 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1481 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1482 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1483
1484 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1485 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1486 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1487
1488 if(IS_SUB_8X8(sub_mb_type)){
1489 mv_cache[ 1 ][0]=
1490 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1491 mv_cache[ 1 ][1]=
1492 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1493
1494 mvd_cache[ 1 ][0]=
1495 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1496 mvd_cache[ 1 ][1]=
1497 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1498 }else if(IS_SUB_8X4(sub_mb_type)){
1499 mv_cache[ 1 ][0]= mx;
1500 mv_cache[ 1 ][1]= my;
1501
1502 mvd_cache[ 1 ][0]= mx - mpx;
1503 mvd_cache[ 1 ][1]= my - mpy;
1504 }else if(IS_SUB_4X8(sub_mb_type)){
1505 mv_cache[ 8 ][0]= mx;
1506 mv_cache[ 8 ][1]= my;
1507
1508 mvd_cache[ 8 ][0]= mx - mpx;
1509 mvd_cache[ 8 ][1]= my - mpy;
1510 }
1511 mv_cache[ 0 ][0]= mx;
1512 mv_cache[ 0 ][1]= my;
1513
1514 mvd_cache[ 0 ][0]= mx - mpx;
1515 mvd_cache[ 0 ][1]= my - mpy;
1516 }
1517 }else{
1518 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1519 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1520 p[0] = p[1] = p[8] = p[9] = 0;
1521 pd[0]= pd[1]= pd[8]= pd[9]= 0;
1522 }
1523 }
1524 }
1525 } else if( IS_DIRECT(mb_type) ) {
1526 ff_h264_pred_direct_motion(h, &mb_type);
1527 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1528 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1529 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1530 } else {
1531 int list, mx, my, i, mpx, mpy;
1532 if(IS_16X16(mb_type)){
1533 for(list=0; list<h->list_count; list++){
1534 if(IS_DIR(mb_type, 0, list)){
1535 int ref;
1536 if(h->ref_count[list] > 1){
1537 ref= decode_cabac_mb_ref(h, list, 0);
1538 if(ref >= (unsigned)h->ref_count[list]){
1539 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1540 return -1;
1541 }
1542 }else
1543 ref=0;
1544 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1545 }else
1546 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
1547 }
1548 for(list=0; list<h->list_count; list++){
1549 if(IS_DIR(mb_type, 0, list)){
1550 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1551
1552 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1553 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1554 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1555
1556 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1557 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1558 }else
1559 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1560 }
1561 }
1562 else if(IS_16X8(mb_type)){
1563 for(list=0; list<h->list_count; list++){
1564 for(i=0; i<2; i++){
1565 if(IS_DIR(mb_type, i, list)){
1566 int ref;
1567 if(h->ref_count[list] > 1){
1568 ref= decode_cabac_mb_ref( h, list, 8*i );
1569 if(ref >= (unsigned)h->ref_count[list]){
1570 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1571 return -1;
1572 }
1573 }else
1574 ref=0;
1575 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1576 }else
1577 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1578 }
1579 }
1580 for(list=0; list<h->list_count; list++){
1581 for(i=0; i<2; i++){
1582 if(IS_DIR(mb_type, i, list)){
1583 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1584 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1585 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1586 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1587
1588 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1589 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1590 }else{
1591 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1592 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1593 }
1594 }
1595 }
1596 }else{
1597 assert(IS_8X16(mb_type));
1598 for(list=0; list<h->list_count; list++){
1599 for(i=0; i<2; i++){
1600 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1601 int ref;
1602 if(h->ref_count[list] > 1){
1603 ref= decode_cabac_mb_ref( h, list, 4*i );
1604 if(ref >= (unsigned)h->ref_count[list]){
1605 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1606 return -1;
1607 }
1608 }else
1609 ref=0;
1610 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1611 }else
1612 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1613 }
1614 }
1615 for(list=0; list<h->list_count; list++){
1616 for(i=0; i<2; i++){
1617 if(IS_DIR(mb_type, i, list)){
1618 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1619 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1620 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1621
1622 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1623 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1624 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1625 }else{
1626 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1627 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1628 }
1629 }
1630 }
1631 }
1632 }
1633
1634 if( IS_INTER( mb_type ) ) {
1635 h->chroma_pred_mode_table[mb_xy] = 0;
1636 write_back_motion( h, mb_type );
1637 }
1638
1639 if( !IS_INTRA16x16( mb_type ) ) {
1640 cbp = decode_cabac_mb_cbp_luma( h );
1641 if(CHROMA)
1642 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1643 }
1644
1645 h->cbp_table[mb_xy] = h->cbp = cbp;
1646
1647 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1648 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1649 }
1650 s->current_picture.mb_type[mb_xy]= mb_type;
1651
1652 if( cbp || IS_INTRA16x16( mb_type ) ) {
1653 const uint8_t *scan, *scan8x8, *dc_scan;
1654 const uint32_t *qmul;
1655
1656 if(IS_INTERLACED(mb_type)){
1657 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1658 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1659 dc_scan= luma_dc_field_scan;
1660 }else{
1661 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1662 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1663 dc_scan= luma_dc_zigzag_scan;
1664 }
1665
1666 // decode_cabac_mb_dqp
1667 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1668 int val = 1;
1669 int ctx= 2;
1670
1671 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1672 ctx= 3;
1673 val++;
1674 if(val > 102){ //prevent infinite loop
1675 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1676 return -1;
1677 }
1678 }
1679
1680 if( val&0x01 )
1681 val= (val + 1)>>1 ;
1682 else
1683 val= -((val + 1)>>1);
1684 h->last_qscale_diff = val;
1685 s->qscale += val;
1686 if(((unsigned)s->qscale) > 51){
1687 if(s->qscale<0) s->qscale+= 52;
1688 else s->qscale-= 52;
1689 }
1690 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1691 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1692 }else
1693 h->last_qscale_diff=0;
1694
1695 if( IS_INTRA16x16( mb_type ) ) {
1696 int i;
1697 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1698 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1699
1700 if( cbp&15 ) {
1701 qmul = h->dequant4_coeff[0][s->qscale];
1702 for( i = 0; i < 16; i++ ) {
1703 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1704 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1705 }
1706 } else {
1707 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1708 }
1709 } else {
1710 int i8x8, i4x4;
1711 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1712 if( cbp & (1<<i8x8) ) {
1713 if( IS_8x8DCT(mb_type) ) {
1714 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1715 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1716 } else {
1717 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1718 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1719 const int index = 4*i8x8 + i4x4;
1720 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1721 //START_TIMER
1722 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1723 //STOP_TIMER("decode_residual")
1724 }
1725 }
1726 } else {
1727 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1728 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1729 }
1730 }
1731 }
1732
1733 if( cbp&0x30 ){
1734 int c;
1735 for( c = 0; c < 2; c++ ) {
1736 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1737 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1738 }
1739 }
1740
1741 if( cbp&0x20 ) {
1742 int c, i;
1743 for( c = 0; c < 2; c++ ) {
1744 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1745 for( i = 0; i < 4; i++ ) {
1746 const int index = 16 + 4 * c + i;
1747 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1748 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1749 }
1750 }
1751 } else {
1752 uint8_t * const nnz= &h->non_zero_count_cache[0];
1753 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1754 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1755 }
1756 } else {
1757 uint8_t * const nnz= &h->non_zero_count_cache[0];
1758 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1759 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1760 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1761 h->last_qscale_diff = 0;
1762 }
1763
1764 s->current_picture.qscale_table[mb_xy]= s->qscale;
1765 write_back_non_zero_count(h);
1766
1767 if(MB_MBAFF){
1768 h->ref_count[0] >>= 1;
1769 h->ref_count[1] >>= 1;
1770 }
1771
1772 return 0;
1773 }