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