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