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