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