Mercurial > libavcodec.hg

comparison h264_cabac.c @ 10869:7101061bfa0f libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Split cabac decoding code out of h264.c. not slower according to benchmarks.
author michael
date Wed, 13 Jan 2010 02:35:36 +0000
parents
children 2aafcafbe1f0
comparison
equal deleted inserted replaced
10868:13a84faba50d 10869:7101061bfa0f
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 #include "internal.h"
29 #include "dsputil.h"
30 #include "avcodec.h"
31 #include "h264.h"
32 #include "h264data.h"
33 #include "h264_mvpred.h"
34 #include "golomb.h"
35
36 #include "cabac.h"
37 #if ARCH_X86
38 #include "x86/h264_i386.h"
39 #endif
40
41 //#undef NDEBUG
42 #include <assert.h>
43
44 /* Cabac pre state table */
45
46 static const int8_t cabac_context_init_I[460][2] =
47 {
48 /* 0 - 10 */
49 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
50 { 2, 54 }, { 3, 74 }, { -28,127 }, { -23, 104 },
51 { -6, 53 }, { -1, 54 }, { 7, 51 },
52
53 /* 11 - 23 unsused for I */
54 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
55 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
56 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
57 { 0, 0 },
58
59 /* 24- 39 */
60 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
61 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
62 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
63 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
64
65 /* 40 - 53 */
66 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
67 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
68 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
69 { 0, 0 }, { 0, 0 },
70
71 /* 54 - 59 */
72 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
73 { 0, 0 }, { 0, 0 },
74
75 /* 60 - 69 */
76 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
77 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
78 { 13, 41 }, { 3, 62 },
79
80 /* 70 -> 87 */
81 { 0, 11 }, { 1, 55 }, { 0, 69 }, { -17, 127 },
82 { -13, 102 },{ 0, 82 }, { -7, 74 }, { -21, 107 },
83 { -27, 127 },{ -31, 127 },{ -24, 127 }, { -18, 95 },
84 { -27, 127 },{ -21, 114 },{ -30, 127 }, { -17, 123 },
85 { -12, 115 },{ -16, 122 },
86
87 /* 88 -> 104 */
88 { -11, 115 },{ -12, 63 }, { -2, 68 }, { -15, 84 },
89 { -13, 104 },{ -3, 70 }, { -8, 93 }, { -10, 90 },
90 { -30, 127 },{ -1, 74 }, { -6, 97 }, { -7, 91 },
91 { -20, 127 },{ -4, 56 }, { -5, 82 }, { -7, 76 },
92 { -22, 125 },
93
94 /* 105 -> 135 */
95 { -7, 93 }, { -11, 87 }, { -3, 77 }, { -5, 71 },
96 { -4, 63 }, { -4, 68 }, { -12, 84 }, { -7, 62 },
97 { -7, 65 }, { 8, 61 }, { 5, 56 }, { -2, 66 },
98 { 1, 64 }, { 0, 61 }, { -2, 78 }, { 1, 50 },
99 { 7, 52 }, { 10, 35 }, { 0, 44 }, { 11, 38 },
100 { 1, 45 }, { 0, 46 }, { 5, 44 }, { 31, 17 },
101 { 1, 51 }, { 7, 50 }, { 28, 19 }, { 16, 33 },
102 { 14, 62 }, { -13, 108 },{ -15, 100 },
103
104 /* 136 -> 165 */
105 { -13, 101 },{ -13, 91 }, { -12, 94 }, { -10, 88 },
106 { -16, 84 }, { -10, 86 }, { -7, 83 }, { -13, 87 },
107 { -19, 94 }, { 1, 70 }, { 0, 72 }, { -5, 74 },
108 { 18, 59 }, { -8, 102 }, { -15, 100 }, { 0, 95 },
109 { -4, 75 }, { 2, 72 }, { -11, 75 }, { -3, 71 },
110 { 15, 46 }, { -13, 69 }, { 0, 62 }, { 0, 65 },
111 { 21, 37 }, { -15, 72 }, { 9, 57 }, { 16, 54 },
112 { 0, 62 }, { 12, 72 },
113
114 /* 166 -> 196 */
115 { 24, 0 }, { 15, 9 }, { 8, 25 }, { 13, 18 },
116 { 15, 9 }, { 13, 19 }, { 10, 37 }, { 12, 18 },
117 { 6, 29 }, { 20, 33 }, { 15, 30 }, { 4, 45 },
118 { 1, 58 }, { 0, 62 }, { 7, 61 }, { 12, 38 },
119 { 11, 45 }, { 15, 39 }, { 11, 42 }, { 13, 44 },
120 { 16, 45 }, { 12, 41 }, { 10, 49 }, { 30, 34 },
121 { 18, 42 }, { 10, 55 }, { 17, 51 }, { 17, 46 },
122 { 0, 89 }, { 26, -19 }, { 22, -17 },
123
124 /* 197 -> 226 */
125 { 26, -17 }, { 30, -25 }, { 28, -20 }, { 33, -23 },
126 { 37, -27 }, { 33, -23 }, { 40, -28 }, { 38, -17 },
127 { 33, -11 }, { 40, -15 }, { 41, -6 }, { 38, 1 },
128 { 41, 17 }, { 30, -6 }, { 27, 3 }, { 26, 22 },
129 { 37, -16 }, { 35, -4 }, { 38, -8 }, { 38, -3 },
130 { 37, 3 }, { 38, 5 }, { 42, 0 }, { 35, 16 },
131 { 39, 22 }, { 14, 48 }, { 27, 37 }, { 21, 60 },
132 { 12, 68 }, { 2, 97 },
133
134 /* 227 -> 251 */
135 { -3, 71 }, { -6, 42 }, { -5, 50 }, { -3, 54 },
136 { -2, 62 }, { 0, 58 }, { 1, 63 }, { -2, 72 },
137 { -1, 74 }, { -9, 91 }, { -5, 67 }, { -5, 27 },
138 { -3, 39 }, { -2, 44 }, { 0, 46 }, { -16, 64 },
139 { -8, 68 }, { -10, 78 }, { -6, 77 }, { -10, 86 },
140 { -12, 92 }, { -15, 55 }, { -10, 60 }, { -6, 62 },
141 { -4, 65 },
142
143 /* 252 -> 275 */
144 { -12, 73 }, { -8, 76 }, { -7, 80 }, { -9, 88 },
145 { -17, 110 },{ -11, 97 }, { -20, 84 }, { -11, 79 },
146 { -6, 73 }, { -4, 74 }, { -13, 86 }, { -13, 96 },
147 { -11, 97 }, { -19, 117 },{ -8, 78 }, { -5, 33 },
148 { -4, 48 }, { -2, 53 }, { -3, 62 }, { -13, 71 },
149 { -10, 79 }, { -12, 86 }, { -13, 90 }, { -14, 97 },
150
151 /* 276 a bit special (not used, bypass is used instead) */
152 { 0, 0 },
153
154 /* 277 -> 307 */
155 { -6, 93 }, { -6, 84 }, { -8, 79 }, { 0, 66 },
156 { -1, 71 }, { 0, 62 }, { -2, 60 }, { -2, 59 },
157 { -5, 75 }, { -3, 62 }, { -4, 58 }, { -9, 66 },
158 { -1, 79 }, { 0, 71 }, { 3, 68 }, { 10, 44 },
159 { -7, 62 }, { 15, 36 }, { 14, 40 }, { 16, 27 },
160 { 12, 29 }, { 1, 44 }, { 20, 36 }, { 18, 32 },
161 { 5, 42 }, { 1, 48 }, { 10, 62 }, { 17, 46 },
162 { 9, 64 }, { -12, 104 },{ -11, 97 },
163
164 /* 308 -> 337 */
165 { -16, 96 }, { -7, 88 }, { -8, 85 }, { -7, 85 },
166 { -9, 85 }, { -13, 88 }, { 4, 66 }, { -3, 77 },
167 { -3, 76 }, { -6, 76 }, { 10, 58 }, { -1, 76 },
168 { -1, 83 }, { -7, 99 }, { -14, 95 }, { 2, 95 },
169 { 0, 76 }, { -5, 74 }, { 0, 70 }, { -11, 75 },
170 { 1, 68 }, { 0, 65 }, { -14, 73 }, { 3, 62 },
171 { 4, 62 }, { -1, 68 }, { -13, 75 }, { 11, 55 },
172 { 5, 64 }, { 12, 70 },
173
174 /* 338 -> 368 */
175 { 15, 6 }, { 6, 19 }, { 7, 16 }, { 12, 14 },
176 { 18, 13 }, { 13, 11 }, { 13, 15 }, { 15, 16 },
177 { 12, 23 }, { 13, 23 }, { 15, 20 }, { 14, 26 },
178 { 14, 44 }, { 17, 40 }, { 17, 47 }, { 24, 17 },
179 { 21, 21 }, { 25, 22 }, { 31, 27 }, { 22, 29 },
180 { 19, 35 }, { 14, 50 }, { 10, 57 }, { 7, 63 },
181 { -2, 77 }, { -4, 82 }, { -3, 94 }, { 9, 69 },
182 { -12, 109 },{ 36, -35 }, { 36, -34 },
183
184 /* 369 -> 398 */
185 { 32, -26 }, { 37, -30 }, { 44, -32 }, { 34, -18 },
186 { 34, -15 }, { 40, -15 }, { 33, -7 }, { 35, -5 },
187 { 33, 0 }, { 38, 2 }, { 33, 13 }, { 23, 35 },
188 { 13, 58 }, { 29, -3 }, { 26, 0 }, { 22, 30 },
189 { 31, -7 }, { 35, -15 }, { 34, -3 }, { 34, 3 },
190 { 36, -1 }, { 34, 5 }, { 32, 11 }, { 35, 5 },
191 { 34, 12 }, { 39, 11 }, { 30, 29 }, { 34, 26 },
192 { 29, 39 }, { 19, 66 },
193
194 /* 399 -> 435 */
195 { 31, 21 }, { 31, 31 }, { 25, 50 },
196 { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11, 85 },
197 { -15, 92 }, { -14, 89 }, { -26, 71 }, { -15, 81 },
198 { -14, 80 }, { 0, 68 }, { -14, 70 }, { -24, 56 },
199 { -23, 68 }, { -24, 50 }, { -11, 74 }, { 23, -13 },
200 { 26, -13 }, { 40, -15 }, { 49, -14 }, { 44, 3 },
201 { 45, 6 }, { 44, 34 }, { 33, 54 }, { 19, 82 },
202 { -3, 75 }, { -1, 23 }, { 1, 34 }, { 1, 43 },
203 { 0, 54 }, { -2, 55 }, { 0, 61 }, { 1, 64 },
204 { 0, 68 }, { -9, 92 },
205
206 /* 436 -> 459 */
207 { -14, 106 }, { -13, 97 }, { -15, 90 }, { -12, 90 },
208 { -18, 88 }, { -10, 73 }, { -9, 79 }, { -14, 86 },
209 { -10, 73 }, { -10, 70 }, { -10, 69 }, { -5, 66 },
210 { -9, 64 }, { -5, 58 }, { 2, 59 }, { 21, -10 },
211 { 24, -11 }, { 28, -8 }, { 28, -1 }, { 29, 3 },
212 { 29, 9 }, { 35, 20 }, { 29, 36 }, { 14, 67 }
213 };
214
215 static const int8_t cabac_context_init_PB[3][460][2] =
216 {
217 /* i_cabac_init_idc == 0 */
218 {
219 /* 0 - 10 */
220 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
221 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
222 { -6, 53 }, { -1, 54 }, { 7, 51 },
223
224 /* 11 - 23 */
225 { 23, 33 }, { 23, 2 }, { 21, 0 }, { 1, 9 },
226 { 0, 49 }, { -37, 118 }, { 5, 57 }, { -13, 78 },
227 { -11, 65 }, { 1, 62 }, { 12, 49 }, { -4, 73 },
228 { 17, 50 },
229
230 /* 24 - 39 */
231 { 18, 64 }, { 9, 43 }, { 29, 0 }, { 26, 67 },
232 { 16, 90 }, { 9, 104 }, { -46, 127 }, { -20, 104 },
233 { 1, 67 }, { -13, 78 }, { -11, 65 }, { 1, 62 },
234 { -6, 86 }, { -17, 95 }, { -6, 61 }, { 9, 45 },
235
236 /* 40 - 53 */
237 { -3, 69 }, { -6, 81 }, { -11, 96 }, { 6, 55 },
238 { 7, 67 }, { -5, 86 }, { 2, 88 }, { 0, 58 },
239 { -3, 76 }, { -10, 94 }, { 5, 54 }, { 4, 69 },
240 { -3, 81 }, { 0, 88 },
241
242 /* 54 - 59 */
243 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
244 { -7, 72 }, { 1, 58 },
245
246 /* 60 - 69 */
247 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
248 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
249 { 13, 41 }, { 3, 62 },
250
251 /* 70 - 87 */
252 { 0, 45 }, { -4, 78 }, { -3, 96 }, { -27, 126 },
253 { -28, 98 }, { -25, 101 }, { -23, 67 }, { -28, 82 },
254 { -20, 94 }, { -16, 83 }, { -22, 110 }, { -21, 91 },
255 { -18, 102 }, { -13, 93 }, { -29, 127 }, { -7, 92 },
256 { -5, 89 }, { -7, 96 }, { -13, 108 }, { -3, 46 },
257 { -1, 65 }, { -1, 57 }, { -9, 93 }, { -3, 74 },
258 { -9, 92 }, { -8, 87 }, { -23, 126 }, { 5, 54 },
259 { 6, 60 }, { 6, 59 }, { 6, 69 }, { -1, 48 },
260 { 0, 68 }, { -4, 69 }, { -8, 88 },
261
262 /* 105 -> 165 */
263 { -2, 85 }, { -6, 78 }, { -1, 75 }, { -7, 77 },
264 { 2, 54 }, { 5, 50 }, { -3, 68 }, { 1, 50 },
265 { 6, 42 }, { -4, 81 }, { 1, 63 }, { -4, 70 },
266 { 0, 67 }, { 2, 57 }, { -2, 76 }, { 11, 35 },
267 { 4, 64 }, { 1, 61 }, { 11, 35 }, { 18, 25 },
268 { 12, 24 }, { 13, 29 }, { 13, 36 }, { -10, 93 },
269 { -7, 73 }, { -2, 73 }, { 13, 46 }, { 9, 49 },
270 { -7, 100 }, { 9, 53 }, { 2, 53 }, { 5, 53 },
271 { -2, 61 }, { 0, 56 }, { 0, 56 }, { -13, 63 },
272 { -5, 60 }, { -1, 62 }, { 4, 57 }, { -6, 69 },
273 { 4, 57 }, { 14, 39 }, { 4, 51 }, { 13, 68 },
274 { 3, 64 }, { 1, 61 }, { 9, 63 }, { 7, 50 },
275 { 16, 39 }, { 5, 44 }, { 4, 52 }, { 11, 48 },
276 { -5, 60 }, { -1, 59 }, { 0, 59 }, { 22, 33 },
277 { 5, 44 }, { 14, 43 }, { -1, 78 }, { 0, 60 },
278 { 9, 69 },
279
280 /* 166 - 226 */
281 { 11, 28 }, { 2, 40 }, { 3, 44 }, { 0, 49 },
282 { 0, 46 }, { 2, 44 }, { 2, 51 }, { 0, 47 },
283 { 4, 39 }, { 2, 62 }, { 6, 46 }, { 0, 54 },
284 { 3, 54 }, { 2, 58 }, { 4, 63 }, { 6, 51 },
285 { 6, 57 }, { 7, 53 }, { 6, 52 }, { 6, 55 },
286 { 11, 45 }, { 14, 36 }, { 8, 53 }, { -1, 82 },
287 { 7, 55 }, { -3, 78 }, { 15, 46 }, { 22, 31 },
288 { -1, 84 }, { 25, 7 }, { 30, -7 }, { 28, 3 },
289 { 28, 4 }, { 32, 0 }, { 34, -1 }, { 30, 6 },
290 { 30, 6 }, { 32, 9 }, { 31, 19 }, { 26, 27 },
291 { 26, 30 }, { 37, 20 }, { 28, 34 }, { 17, 70 },
292 { 1, 67 }, { 5, 59 }, { 9, 67 }, { 16, 30 },
293 { 18, 32 }, { 18, 35 }, { 22, 29 }, { 24, 31 },
294 { 23, 38 }, { 18, 43 }, { 20, 41 }, { 11, 63 },
295 { 9, 59 }, { 9, 64 }, { -1, 94 }, { -2, 89 },
296 { -9, 108 },
297
298 /* 227 - 275 */
299 { -6, 76 }, { -2, 44 }, { 0, 45 }, { 0, 52 },
300 { -3, 64 }, { -2, 59 }, { -4, 70 }, { -4, 75 },
301 { -8, 82 }, { -17, 102 }, { -9, 77 }, { 3, 24 },
302 { 0, 42 }, { 0, 48 }, { 0, 55 }, { -6, 59 },
303 { -7, 71 }, { -12, 83 }, { -11, 87 }, { -30, 119 },
304 { 1, 58 }, { -3, 29 }, { -1, 36 }, { 1, 38 },
305 { 2, 43 }, { -6, 55 }, { 0, 58 }, { 0, 64 },
306 { -3, 74 }, { -10, 90 }, { 0, 70 }, { -4, 29 },
307 { 5, 31 }, { 7, 42 }, { 1, 59 }, { -2, 58 },
308 { -3, 72 }, { -3, 81 }, { -11, 97 }, { 0, 58 },
309 { 8, 5 }, { 10, 14 }, { 14, 18 }, { 13, 27 },
310 { 2, 40 }, { 0, 58 }, { -3, 70 }, { -6, 79 },
311 { -8, 85 },
312
313 /* 276 a bit special (not used, bypass is used instead) */
314 { 0, 0 },
315
316 /* 277 - 337 */
317 { -13, 106 }, { -16, 106 }, { -10, 87 }, { -21, 114 },
318 { -18, 110 }, { -14, 98 }, { -22, 110 }, { -21, 106 },
319 { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
320 { -10, 96 }, { -12, 95 }, { -5, 91 }, { -9, 93 },
321 { -22, 94 }, { -5, 86 }, { 9, 67 }, { -4, 80 },
322 { -10, 85 }, { -1, 70 }, { 7, 60 }, { 9, 58 },
323 { 5, 61 }, { 12, 50 }, { 15, 50 }, { 18, 49 },
324 { 17, 54 }, { 10, 41 }, { 7, 46 }, { -1, 51 },
325 { 7, 49 }, { 8, 52 }, { 9, 41 }, { 6, 47 },
326 { 2, 55 }, { 13, 41 }, { 10, 44 }, { 6, 50 },
327 { 5, 53 }, { 13, 49 }, { 4, 63 }, { 6, 64 },
328 { -2, 69 }, { -2, 59 }, { 6, 70 }, { 10, 44 },
329 { 9, 31 }, { 12, 43 }, { 3, 53 }, { 14, 34 },
330 { 10, 38 }, { -3, 52 }, { 13, 40 }, { 17, 32 },
331 { 7, 44 }, { 7, 38 }, { 13, 50 }, { 10, 57 },
332 { 26, 43 },
333
334 /* 338 - 398 */
335 { 14, 11 }, { 11, 14 }, { 9, 11 }, { 18, 11 },
336 { 21, 9 }, { 23, -2 }, { 32, -15 }, { 32, -15 },
337 { 34, -21 }, { 39, -23 }, { 42, -33 }, { 41, -31 },
338 { 46, -28 }, { 38, -12 }, { 21, 29 }, { 45, -24 },
339 { 53, -45 }, { 48, -26 }, { 65, -43 }, { 43, -19 },
340 { 39, -10 }, { 30, 9 }, { 18, 26 }, { 20, 27 },
341 { 0, 57 }, { -14, 82 }, { -5, 75 }, { -19, 97 },
342 { -35, 125 }, { 27, 0 }, { 28, 0 }, { 31, -4 },
343 { 27, 6 }, { 34, 8 }, { 30, 10 }, { 24, 22 },
344 { 33, 19 }, { 22, 32 }, { 26, 31 }, { 21, 41 },
345 { 26, 44 }, { 23, 47 }, { 16, 65 }, { 14, 71 },
346 { 8, 60 }, { 6, 63 }, { 17, 65 }, { 21, 24 },
347 { 23, 20 }, { 26, 23 }, { 27, 32 }, { 28, 23 },
348 { 28, 24 }, { 23, 40 }, { 24, 32 }, { 28, 29 },
349 { 23, 42 }, { 19, 57 }, { 22, 53 }, { 22, 61 },
350 { 11, 86 },
351
352 /* 399 - 435 */
353 { 12, 40 }, { 11, 51 }, { 14, 59 },
354 { -4, 79 }, { -7, 71 }, { -5, 69 }, { -9, 70 },
355 { -8, 66 }, { -10, 68 }, { -19, 73 }, { -12, 69 },
356 { -16, 70 }, { -15, 67 }, { -20, 62 }, { -19, 70 },
357 { -16, 66 }, { -22, 65 }, { -20, 63 }, { 9, -2 },
358 { 26, -9 }, { 33, -9 }, { 39, -7 }, { 41, -2 },
359 { 45, 3 }, { 49, 9 }, { 45, 27 }, { 36, 59 },
360 { -6, 66 }, { -7, 35 }, { -7, 42 }, { -8, 45 },
361 { -5, 48 }, { -12, 56 }, { -6, 60 }, { -5, 62 },
362 { -8, 66 }, { -8, 76 },
363
364 /* 436 - 459 */
365 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
366 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
367 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
368 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 21, -13 },
369 { 33, -14 }, { 39, -7 }, { 46, -2 }, { 51, 2 },
370 { 60, 6 }, { 61, 17 }, { 55, 34 }, { 42, 62 },
371 },
372
373 /* i_cabac_init_idc == 1 */
374 {
375 /* 0 - 10 */
376 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
377 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
378 { -6, 53 }, { -1, 54 }, { 7, 51 },
379
380 /* 11 - 23 */
381 { 22, 25 }, { 34, 0 }, { 16, 0 }, { -2, 9 },
382 { 4, 41 }, { -29, 118 }, { 2, 65 }, { -6, 71 },
383 { -13, 79 }, { 5, 52 }, { 9, 50 }, { -3, 70 },
384 { 10, 54 },
385
386 /* 24 - 39 */
387 { 26, 34 }, { 19, 22 }, { 40, 0 }, { 57, 2 },
388 { 41, 36 }, { 26, 69 }, { -45, 127 }, { -15, 101 },
389 { -4, 76 }, { -6, 71 }, { -13, 79 }, { 5, 52 },
390 { 6, 69 }, { -13, 90 }, { 0, 52 }, { 8, 43 },
391
392 /* 40 - 53 */
393 { -2, 69 },{ -5, 82 },{ -10, 96 },{ 2, 59 },
394 { 2, 75 },{ -3, 87 },{ -3, 100 },{ 1, 56 },
395 { -3, 74 },{ -6, 85 },{ 0, 59 },{ -3, 81 },
396 { -7, 86 },{ -5, 95 },
397
398 /* 54 - 59 */
399 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
400 { -5, 72 },{ 0, 61 },
401
402 /* 60 - 69 */
403 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
404 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
405 { 13, 41 }, { 3, 62 },
406
407 /* 70 - 104 */
408 { 13, 15 }, { 7, 51 }, { 2, 80 }, { -39, 127 },
409 { -18, 91 }, { -17, 96 }, { -26, 81 }, { -35, 98 },
410 { -24, 102 }, { -23, 97 }, { -27, 119 }, { -24, 99 },
411 { -21, 110 }, { -18, 102 }, { -36, 127 }, { 0, 80 },
412 { -5, 89 }, { -7, 94 }, { -4, 92 }, { 0, 39 },
413 { 0, 65 }, { -15, 84 }, { -35, 127 }, { -2, 73 },
414 { -12, 104 }, { -9, 91 }, { -31, 127 }, { 3, 55 },
415 { 7, 56 }, { 7, 55 }, { 8, 61 }, { -3, 53 },
416 { 0, 68 }, { -7, 74 }, { -9, 88 },
417
418 /* 105 -> 165 */
419 { -13, 103 }, { -13, 91 }, { -9, 89 }, { -14, 92 },
420 { -8, 76 }, { -12, 87 }, { -23, 110 }, { -24, 105 },
421 { -10, 78 }, { -20, 112 }, { -17, 99 }, { -78, 127 },
422 { -70, 127 }, { -50, 127 }, { -46, 127 }, { -4, 66 },
423 { -5, 78 }, { -4, 71 }, { -8, 72 }, { 2, 59 },
424 { -1, 55 }, { -7, 70 }, { -6, 75 }, { -8, 89 },
425 { -34, 119 }, { -3, 75 }, { 32, 20 }, { 30, 22 },
426 { -44, 127 }, { 0, 54 }, { -5, 61 }, { 0, 58 },
427 { -1, 60 }, { -3, 61 }, { -8, 67 }, { -25, 84 },
428 { -14, 74 }, { -5, 65 }, { 5, 52 }, { 2, 57 },
429 { 0, 61 }, { -9, 69 }, { -11, 70 }, { 18, 55 },
430 { -4, 71 }, { 0, 58 }, { 7, 61 }, { 9, 41 },
431 { 18, 25 }, { 9, 32 }, { 5, 43 }, { 9, 47 },
432 { 0, 44 }, { 0, 51 }, { 2, 46 }, { 19, 38 },
433 { -4, 66 }, { 15, 38 }, { 12, 42 }, { 9, 34 },
434 { 0, 89 },
435
436 /* 166 - 226 */
437 { 4, 45 }, { 10, 28 }, { 10, 31 }, { 33, -11 },
438 { 52, -43 }, { 18, 15 }, { 28, 0 }, { 35, -22 },
439 { 38, -25 }, { 34, 0 }, { 39, -18 }, { 32, -12 },
440 { 102, -94 }, { 0, 0 }, { 56, -15 }, { 33, -4 },
441 { 29, 10 }, { 37, -5 }, { 51, -29 }, { 39, -9 },
442 { 52, -34 }, { 69, -58 }, { 67, -63 }, { 44, -5 },
443 { 32, 7 }, { 55, -29 }, { 32, 1 }, { 0, 0 },
444 { 27, 36 }, { 33, -25 }, { 34, -30 }, { 36, -28 },
445 { 38, -28 }, { 38, -27 }, { 34, -18 }, { 35, -16 },
446 { 34, -14 }, { 32, -8 }, { 37, -6 }, { 35, 0 },
447 { 30, 10 }, { 28, 18 }, { 26, 25 }, { 29, 41 },
448 { 0, 75 }, { 2, 72 }, { 8, 77 }, { 14, 35 },
449 { 18, 31 }, { 17, 35 }, { 21, 30 }, { 17, 45 },
450 { 20, 42 }, { 18, 45 }, { 27, 26 }, { 16, 54 },
451 { 7, 66 }, { 16, 56 }, { 11, 73 }, { 10, 67 },
452 { -10, 116 },
453
454 /* 227 - 275 */
455 { -23, 112 }, { -15, 71 }, { -7, 61 }, { 0, 53 },
456 { -5, 66 }, { -11, 77 }, { -9, 80 }, { -9, 84 },
457 { -10, 87 }, { -34, 127 }, { -21, 101 }, { -3, 39 },
458 { -5, 53 }, { -7, 61 }, { -11, 75 }, { -15, 77 },
459 { -17, 91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
460 { -11, 76 }, { -10, 44 }, { -10, 52 }, { -10, 57 },
461 { -9, 58 }, { -16, 72 }, { -7, 69 }, { -4, 69 },
462 { -5, 74 }, { -9, 86 }, { 2, 66 }, { -9, 34 },
463 { 1, 32 }, { 11, 31 }, { 5, 52 }, { -2, 55 },
464 { -2, 67 }, { 0, 73 }, { -8, 89 }, { 3, 52 },
465 { 7, 4 }, { 10, 8 }, { 17, 8 }, { 16, 19 },
466 { 3, 37 }, { -1, 61 }, { -5, 73 }, { -1, 70 },
467 { -4, 78 },
468
469 /* 276 a bit special (not used, bypass is used instead) */
470 { 0, 0 },
471
472 /* 277 - 337 */
473 { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
474 { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
475 { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
476 { -10, 95 }, { -14, 100 }, { -8, 95 }, { -17, 111 },
477 { -28, 114 }, { -6, 89 }, { -2, 80 }, { -4, 82 },
478 { -9, 85 }, { -8, 81 }, { -1, 72 }, { 5, 64 },
479 { 1, 67 }, { 9, 56 }, { 0, 69 }, { 1, 69 },
480 { 7, 69 }, { -7, 69 }, { -6, 67 }, { -16, 77 },
481 { -2, 64 }, { 2, 61 }, { -6, 67 }, { -3, 64 },
482 { 2, 57 }, { -3, 65 }, { -3, 66 }, { 0, 62 },
483 { 9, 51 }, { -1, 66 }, { -2, 71 }, { -2, 75 },
484 { -1, 70 }, { -9, 72 }, { 14, 60 }, { 16, 37 },
485 { 0, 47 }, { 18, 35 }, { 11, 37 }, { 12, 41 },
486 { 10, 41 }, { 2, 48 }, { 12, 41 }, { 13, 41 },
487 { 0, 59 }, { 3, 50 }, { 19, 40 }, { 3, 66 },
488 { 18, 50 },
489
490 /* 338 - 398 */
491 { 19, -6 }, { 18, -6 }, { 14, 0 }, { 26, -12 },
492 { 31, -16 }, { 33, -25 }, { 33, -22 }, { 37, -28 },
493 { 39, -30 }, { 42, -30 }, { 47, -42 }, { 45, -36 },
494 { 49, -34 }, { 41, -17 }, { 32, 9 }, { 69, -71 },
495 { 63, -63 }, { 66, -64 }, { 77, -74 }, { 54, -39 },
496 { 52, -35 }, { 41, -10 }, { 36, 0 }, { 40, -1 },
497 { 30, 14 }, { 28, 26 }, { 23, 37 }, { 12, 55 },
498 { 11, 65 }, { 37, -33 }, { 39, -36 }, { 40, -37 },
499 { 38, -30 }, { 46, -33 }, { 42, -30 }, { 40, -24 },
500 { 49, -29 }, { 38, -12 }, { 40, -10 }, { 38, -3 },
501 { 46, -5 }, { 31, 20 }, { 29, 30 }, { 25, 44 },
502 { 12, 48 }, { 11, 49 }, { 26, 45 }, { 22, 22 },
503 { 23, 22 }, { 27, 21 }, { 33, 20 }, { 26, 28 },
504 { 30, 24 }, { 27, 34 }, { 18, 42 }, { 25, 39 },
505 { 18, 50 }, { 12, 70 }, { 21, 54 }, { 14, 71 },
506 { 11, 83 },
507
508 /* 399 - 435 */
509 { 25, 32 }, { 21, 49 }, { 21, 54 },
510 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
511 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
512 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
513 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 17, -10 },
514 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
515 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
516 { -5, 71 }, { 0, 24 }, { -1, 36 }, { -2, 42 },
517 { -2, 52 }, { -9, 57 }, { -6, 63 }, { -4, 65 },
518 { -4, 67 }, { -7, 82 },
519
520 /* 436 - 459 */
521 { -3, 81 }, { -3, 76 }, { -7, 72 }, { -6, 78 },
522 { -12, 72 }, { -14, 68 }, { -3, 70 }, { -6, 76 },
523 { -5, 66 }, { -5, 62 }, { 0, 57 }, { -4, 61 },
524 { -9, 60 }, { 1, 54 }, { 2, 58 }, { 17, -10 },
525 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
526 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
527 },
528
529 /* i_cabac_init_idc == 2 */
530 {
531 /* 0 - 10 */
532 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
533 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
534 { -6, 53 }, { -1, 54 }, { 7, 51 },
535
536 /* 11 - 23 */
537 { 29, 16 }, { 25, 0 }, { 14, 0 }, { -10, 51 },
538 { -3, 62 }, { -27, 99 }, { 26, 16 }, { -4, 85 },
539 { -24, 102 }, { 5, 57 }, { 6, 57 }, { -17, 73 },
540 { 14, 57 },
541
542 /* 24 - 39 */
543 { 20, 40 }, { 20, 10 }, { 29, 0 }, { 54, 0 },
544 { 37, 42 }, { 12, 97 }, { -32, 127 }, { -22, 117 },
545 { -2, 74 }, { -4, 85 }, { -24, 102 }, { 5, 57 },
546 { -6, 93 }, { -14, 88 }, { -6, 44 }, { 4, 55 },
547
548 /* 40 - 53 */
549 { -11, 89 },{ -15, 103 },{ -21, 116 },{ 19, 57 },
550 { 20, 58 },{ 4, 84 },{ 6, 96 },{ 1, 63 },
551 { -5, 85 },{ -13, 106 },{ 5, 63 },{ 6, 75 },
552 { -3, 90 },{ -1, 101 },
553
554 /* 54 - 59 */
555 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
556 { -7, 50 },{ 1, 60 },
557
558 /* 60 - 69 */
559 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
560 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
561 { 13, 41 }, { 3, 62 },
562
563 /* 70 - 104 */
564 { 7, 34 }, { -9, 88 }, { -20, 127 }, { -36, 127 },
565 { -17, 91 }, { -14, 95 }, { -25, 84 }, { -25, 86 },
566 { -12, 89 }, { -17, 91 }, { -31, 127 }, { -14, 76 },
567 { -18, 103 }, { -13, 90 }, { -37, 127 }, { 11, 80 },
568 { 5, 76 }, { 2, 84 }, { 5, 78 }, { -6, 55 },
569 { 4, 61 }, { -14, 83 }, { -37, 127 }, { -5, 79 },
570 { -11, 104 }, { -11, 91 }, { -30, 127 }, { 0, 65 },
571 { -2, 79 }, { 0, 72 }, { -4, 92 }, { -6, 56 },
572 { 3, 68 }, { -8, 71 }, { -13, 98 },
573
574 /* 105 -> 165 */
575 { -4, 86 }, { -12, 88 }, { -5, 82 }, { -3, 72 },
576 { -4, 67 }, { -8, 72 }, { -16, 89 }, { -9, 69 },
577 { -1, 59 }, { 5, 66 }, { 4, 57 }, { -4, 71 },
578 { -2, 71 }, { 2, 58 }, { -1, 74 }, { -4, 44 },
579 { -1, 69 }, { 0, 62 }, { -7, 51 }, { -4, 47 },
580 { -6, 42 }, { -3, 41 }, { -6, 53 }, { 8, 76 },
581 { -9, 78 }, { -11, 83 }, { 9, 52 }, { 0, 67 },
582 { -5, 90 }, { 1, 67 }, { -15, 72 }, { -5, 75 },
583 { -8, 80 }, { -21, 83 }, { -21, 64 }, { -13, 31 },
584 { -25, 64 }, { -29, 94 }, { 9, 75 }, { 17, 63 },
585 { -8, 74 }, { -5, 35 }, { -2, 27 }, { 13, 91 },
586 { 3, 65 }, { -7, 69 }, { 8, 77 }, { -10, 66 },
587 { 3, 62 }, { -3, 68 }, { -20, 81 }, { 0, 30 },
588 { 1, 7 }, { -3, 23 }, { -21, 74 }, { 16, 66 },
589 { -23, 124 }, { 17, 37 }, { 44, -18 }, { 50, -34 },
590 { -22, 127 },
591
592 /* 166 - 226 */
593 { 4, 39 }, { 0, 42 }, { 7, 34 }, { 11, 29 },
594 { 8, 31 }, { 6, 37 }, { 7, 42 }, { 3, 40 },
595 { 8, 33 }, { 13, 43 }, { 13, 36 }, { 4, 47 },
596 { 3, 55 }, { 2, 58 }, { 6, 60 }, { 8, 44 },
597 { 11, 44 }, { 14, 42 }, { 7, 48 }, { 4, 56 },
598 { 4, 52 }, { 13, 37 }, { 9, 49 }, { 19, 58 },
599 { 10, 48 }, { 12, 45 }, { 0, 69 }, { 20, 33 },
600 { 8, 63 }, { 35, -18 }, { 33, -25 }, { 28, -3 },
601 { 24, 10 }, { 27, 0 }, { 34, -14 }, { 52, -44 },
602 { 39, -24 }, { 19, 17 }, { 31, 25 }, { 36, 29 },
603 { 24, 33 }, { 34, 15 }, { 30, 20 }, { 22, 73 },
604 { 20, 34 }, { 19, 31 }, { 27, 44 }, { 19, 16 },
605 { 15, 36 }, { 15, 36 }, { 21, 28 }, { 25, 21 },
606 { 30, 20 }, { 31, 12 }, { 27, 16 }, { 24, 42 },
607 { 0, 93 }, { 14, 56 }, { 15, 57 }, { 26, 38 },
608 { -24, 127 },
609
610 /* 227 - 275 */
611 { -24, 115 }, { -22, 82 }, { -9, 62 }, { 0, 53 },
612 { 0, 59 }, { -14, 85 }, { -13, 89 }, { -13, 94 },
613 { -11, 92 }, { -29, 127 }, { -21, 100 }, { -14, 57 },
614 { -12, 67 }, { -11, 71 }, { -10, 77 }, { -21, 85 },
615 { -16, 88 }, { -23, 104 }, { -15, 98 }, { -37, 127 },
616 { -10, 82 }, { -8, 48 }, { -8, 61 }, { -8, 66 },
617 { -7, 70 }, { -14, 75 }, { -10, 79 }, { -9, 83 },
618 { -12, 92 }, { -18, 108 }, { -4, 79 }, { -22, 69 },
619 { -16, 75 }, { -2, 58 }, { 1, 58 }, { -13, 78 },
620 { -9, 83 }, { -4, 81 }, { -13, 99 }, { -13, 81 },
621 { -6, 38 }, { -13, 62 }, { -6, 58 }, { -2, 59 },
622 { -16, 73 }, { -10, 76 }, { -13, 86 }, { -9, 83 },
623 { -10, 87 },
624
625 /* 276 a bit special (not used, bypass is used instead) */
626 { 0, 0 },
627
628 /* 277 - 337 */
629 { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
630 { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
631 { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
632 { -10, 94 }, { -15, 102 }, { -10, 99 }, { -13, 106 },
633 { -50, 127 }, { -5, 92 }, { 17, 57 }, { -5, 86 },
634 { -13, 94 }, { -12, 91 }, { -2, 77 }, { 0, 71 },
635 { -1, 73 }, { 4, 64 }, { -7, 81 }, { 5, 64 },
636 { 15, 57 }, { 1, 67 }, { 0, 68 }, { -10, 67 },
637 { 1, 68 }, { 0, 77 }, { 2, 64 }, { 0, 68 },
638 { -5, 78 }, { 7, 55 }, { 5, 59 }, { 2, 65 },
639 { 14, 54 }, { 15, 44 }, { 5, 60 }, { 2, 70 },
640 { -2, 76 }, { -18, 86 }, { 12, 70 }, { 5, 64 },
641 { -12, 70 }, { 11, 55 }, { 5, 56 }, { 0, 69 },
642 { 2, 65 }, { -6, 74 }, { 5, 54 }, { 7, 54 },
643 { -6, 76 }, { -11, 82 }, { -2, 77 }, { -2, 77 },
644 { 25, 42 },
645
646 /* 338 - 398 */
647 { 17, -13 }, { 16, -9 }, { 17, -12 }, { 27, -21 },
648 { 37, -30 }, { 41, -40 }, { 42, -41 }, { 48, -47 },
649 { 39, -32 }, { 46, -40 }, { 52, -51 }, { 46, -41 },
650 { 52, -39 }, { 43, -19 }, { 32, 11 }, { 61, -55 },
651 { 56, -46 }, { 62, -50 }, { 81, -67 }, { 45, -20 },
652 { 35, -2 }, { 28, 15 }, { 34, 1 }, { 39, 1 },
653 { 30, 17 }, { 20, 38 }, { 18, 45 }, { 15, 54 },
654 { 0, 79 }, { 36, -16 }, { 37, -14 }, { 37, -17 },
655 { 32, 1 }, { 34, 15 }, { 29, 15 }, { 24, 25 },
656 { 34, 22 }, { 31, 16 }, { 35, 18 }, { 31, 28 },
657 { 33, 41 }, { 36, 28 }, { 27, 47 }, { 21, 62 },
658 { 18, 31 }, { 19, 26 }, { 36, 24 }, { 24, 23 },
659 { 27, 16 }, { 24, 30 }, { 31, 29 }, { 22, 41 },
660 { 22, 42 }, { 16, 60 }, { 15, 52 }, { 14, 60 },
661 { 3, 78 }, { -16, 123 }, { 21, 53 }, { 22, 56 },
662 { 25, 61 },
663
664 /* 399 - 435 */
665 { 21, 33 }, { 19, 50 }, { 17, 61 },
666 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
667 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
668 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
669 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
670 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
671 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
672 { -9, 71 }, { -7, 37 }, { -8, 44 }, { -11, 49 },
673 { -10, 56 }, { -12, 59 }, { -8, 63 }, { -9, 67 },
674 { -6, 68 }, { -10, 79 },
675
676 /* 436 - 459 */
677 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
678 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
679 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
680 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
681 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
682 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
683 }
684 };
685
686 void ff_h264_init_cabac_states(H264Context *h) {
687 MpegEncContext * const s = &h->s;
688 int i;
689
690 /* calculate pre-state */
691 for( i= 0; i < 460; i++ ) {
692 int pre;
693 if( h->slice_type_nos == FF_I_TYPE )
694 pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
695 else
696 pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
697
698 if( pre <= 63 )
699 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
700 else
701 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
702 }
703 }
704
705 static int decode_cabac_field_decoding_flag(H264Context *h) {
706 MpegEncContext * const s = &h->s;
707 const int mb_x = s->mb_x;
708 const int mb_y = s->mb_y & ~1;
709 const int mba_xy = mb_x - 1 + mb_y *s->mb_stride;
710 const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride;
711
712 unsigned int ctx = 0;
713
714 if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
715 ctx += 1;
716 }
717 if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
718 ctx += 1;
719 }
720
721 return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );
722 }
723
724 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
725 uint8_t *state= &h->cabac_state[ctx_base];
726 int mb_type;
727
728 if(intra_slice){
729 MpegEncContext * const s = &h->s;
730 const int mba_xy = h->left_mb_xy[0];
731 const int mbb_xy = h->top_mb_xy;
732 int ctx=0;
733 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
734 ctx++;
735 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
736 ctx++;
737 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
738 return 0; /* I4x4 */
739 state += 2;
740 }else{
741 if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 )
742 return 0; /* I4x4 */
743 }
744
745 if( get_cabac_terminate( &h->cabac ) )
746 return 25; /* PCM */
747
748 mb_type = 1; /* I16x16 */
749 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
750 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
751 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
752 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
753 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
754 return mb_type;
755 }
756
757 static int decode_cabac_mb_type_b( H264Context *h ) {
758 MpegEncContext * const s = &h->s;
759
760 const int mba_xy = h->left_mb_xy[0];
761 const int mbb_xy = h->top_mb_xy;
762 int ctx = 0;
763 int bits;
764 assert(h->slice_type_nos == FF_B_TYPE);
765
766 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
767 ctx++;
768 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
769 ctx++;
770
771 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
772 return 0; /* B_Direct_16x16 */
773
774 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
775 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
776 }
777
778 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
779 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
780 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
781 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
782 if( bits < 8 )
783 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
784 else if( bits == 13 ) {
785 return decode_cabac_intra_mb_type(h, 32, 0) + 23;
786 } else if( bits == 14 )
787 return 11; /* B_L1_L0_8x16 */
788 else if( bits == 15 )
789 return 22; /* B_8x8 */
790
791 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
792 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
793 }
794
795 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
796 MpegEncContext * const s = &h->s;
797 int mba_xy, mbb_xy;
798 int ctx = 0;
799
800 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
801 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
802 mba_xy = mb_xy - 1;
803 if( (mb_y&1)
804 && h->slice_table[mba_xy] == h->slice_num
805 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
806 mba_xy += s->mb_stride;
807 if( MB_FIELD ){
808 mbb_xy = mb_xy - s->mb_stride;
809 if( !(mb_y&1)
810 && h->slice_table[mbb_xy] == h->slice_num
811 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
812 mbb_xy -= s->mb_stride;
813 }else
814 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
815 }else{
816 int mb_xy = h->mb_xy;
817 mba_xy = mb_xy - 1;
818 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
819 }
820
821 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
822 ctx++;
823 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
824 ctx++;
825
826 if( h->slice_type_nos == FF_B_TYPE )
827 ctx += 13;
828 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
829 }
830
831 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
832 int mode = 0;
833
834 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
835 return pred_mode;
836
837 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
838 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
839 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
840
841 if( mode >= pred_mode )
842 return mode + 1;
843 else
844 return mode;
845 }
846
847 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
848 const int mba_xy = h->left_mb_xy[0];
849 const int mbb_xy = h->top_mb_xy;
850
851 int ctx = 0;
852
853 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
854 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
855 ctx++;
856
857 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
858 ctx++;
859
860 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
861 return 0;
862
863 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
864 return 1;
865 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
866 return 2;
867 else
868 return 3;
869 }
870
871 static int decode_cabac_mb_cbp_luma( H264Context *h) {
872 int cbp_b, cbp_a, ctx, cbp = 0;
873
874 cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1;
875 cbp_b = h->slice_table[h->top_mb_xy] == h->slice_num ? h->top_cbp : -1;
876
877 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
878 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
879 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08);
880 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
881 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01);
882 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
883 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02);
884 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
885 return cbp;
886 }
887 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
888 int ctx;
889 int cbp_a, cbp_b;
890
891 cbp_a = (h->left_cbp>>4)&0x03;
892 cbp_b = (h-> top_cbp>>4)&0x03;
893
894 ctx = 0;
895 if( cbp_a > 0 ) ctx++;
896 if( cbp_b > 0 ) ctx += 2;
897 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
898 return 0;
899
900 ctx = 4;
901 if( cbp_a == 2 ) ctx++;
902 if( cbp_b == 2 ) ctx += 2;
903 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
904 }
905 static int decode_cabac_mb_dqp( H264Context *h) {
906 int ctx= h->last_qscale_diff != 0;
907 int val = 0;
908
909 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
910 ctx= 2+(ctx>>1);
911 val++;
912 if(val > 102) //prevent infinite loop
913 return INT_MIN;
914 }
915
916 if( val&0x01 )
917 return (val + 1)>>1 ;
918 else
919 return -((val + 1)>>1);
920 }
921 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
922 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
923 return 0; /* 8x8 */
924 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
925 return 1; /* 8x4 */
926 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
927 return 2; /* 4x8 */
928 return 3; /* 4x4 */
929 }
930 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
931 int type;
932 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
933 return 0; /* B_Direct_8x8 */
934 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
935 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
936 type = 3;
937 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
938 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
939 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
940 type += 4;
941 }
942 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
943 type += get_cabac( &h->cabac, &h->cabac_state[39] );
944 return type;
945 }
946
947 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
948 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
949 }
950
951 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
952 int refa = h->ref_cache[list][scan8[n] - 1];
953 int refb = h->ref_cache[list][scan8[n] - 8];
954 int ref = 0;
955 int ctx = 0;
956
957 if( h->slice_type_nos == FF_B_TYPE) {
958 if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
959 ctx++;
960 if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
961 ctx += 2;
962 } else {
963 if( refa > 0 )
964 ctx++;
965 if( refb > 0 )
966 ctx += 2;
967 }
968
969 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
970 ref++;
971 ctx = (ctx>>2)+4;
972 if(ref >= 32 /*h->ref_list[list]*/){
973 return -1;
974 }
975 }
976 return ref;
977 }
978
979 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
980 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
981 abs( h->mvd_cache[list][scan8[n] - 8][l] );
982 int ctxbase = (l == 0) ? 40 : 47;
983 int mvd;
984 int ctx = (amvd>2) + (amvd>32);
985
986 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
987 return 0;
988
989 mvd= 1;
990 ctx= 3;
991 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
992 mvd++;
993 if( ctx < 6 )
994 ctx++;
995 }
996
997 if( mvd >= 9 ) {
998 int k = 3;
999 while( get_cabac_bypass( &h->cabac ) ) {
1000 mvd += 1 << k;
1001 k++;
1002 if(k>24){
1003 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
1004 return INT_MIN;
1005 }
1006 }
1007 while( k-- ) {
1008 if( get_cabac_bypass( &h->cabac ) )
1009 mvd += 1 << k;
1010 }
1011 }
1012 return get_cabac_bypass_sign( &h->cabac, -mvd );
1013 }
1014
1015 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
1016 int nza, nzb;
1017 int ctx = 0;
1018
1019 if( is_dc ) {
1020 if( cat == 0 ) {
1021 nza = h->left_cbp&0x100;
1022 nzb = h-> top_cbp&0x100;
1023 } else {
1024 nza = (h->left_cbp>>(6+idx))&0x01;
1025 nzb = (h-> top_cbp>>(6+idx))&0x01;
1026 }
1027 } else {
1028 assert(cat == 1 || cat == 2 || cat == 4);
1029 nza = h->non_zero_count_cache[scan8[idx] - 1];
1030 nzb = h->non_zero_count_cache[scan8[idx] - 8];
1031 }
1032
1033 if( nza > 0 )
1034 ctx++;
1035
1036 if( nzb > 0 )
1037 ctx += 2;
1038
1039 return ctx + 4 * cat;
1040 }
1041
1042 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8[63]) = {
1043 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1044 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1045 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1046 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1047 };
1048
1049 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 ) {
1050 static const int significant_coeff_flag_offset[2][6] = {
1051 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1052 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1053 };
1054 static const int last_coeff_flag_offset[2][6] = {
1055 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1056 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1057 };
1058 static const int coeff_abs_level_m1_offset[6] = {
1059 227+0, 227+10, 227+20, 227+30, 227+39, 426
1060 };
1061 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1062 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1063 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1064 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1065 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1066 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1067 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1068 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1069 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1070 };
1071 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1072 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1073 * map node ctx => cabac ctx for level=1 */
1074 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1075 /* map node ctx => cabac ctx for level>1 */
1076 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1077 static const uint8_t coeff_abs_level_transition[2][8] = {
1078 /* update node ctx after decoding a level=1 */
1079 { 1, 2, 3, 3, 4, 5, 6, 7 },
1080 /* update node ctx after decoding a level>1 */
1081 { 4, 4, 4, 4, 5, 6, 7, 7 }
1082 };
1083
1084 int index[64];
1085
1086 int av_unused last;
1087 int coeff_count = 0;
1088 int node_ctx = 0;
1089
1090 uint8_t *significant_coeff_ctx_base;
1091 uint8_t *last_coeff_ctx_base;
1092 uint8_t *abs_level_m1_ctx_base;
1093
1094 #if !ARCH_X86
1095 #define CABAC_ON_STACK
1096 #endif
1097 #ifdef CABAC_ON_STACK
1098 #define CC &cc
1099 CABACContext cc;
1100 cc.range = h->cabac.range;
1101 cc.low = h->cabac.low;
1102 cc.bytestream= h->cabac.bytestream;
1103 #else
1104 #define CC &h->cabac
1105 #endif
1106
1107
1108 /* cat: 0-> DC 16x16 n = 0
1109 * 1-> AC 16x16 n = luma4x4idx
1110 * 2-> Luma4x4 n = luma4x4idx
1111 * 3-> DC Chroma n = iCbCr
1112 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1113 * 5-> Luma8x8 n = 4 * luma8x8idx
1114 */
1115
1116 /* read coded block flag */
1117 if( is_dc || cat != 5 ) {
1118 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1119 if( !is_dc )
1120 h->non_zero_count_cache[scan8[n]] = 0;
1121
1122 #ifdef CABAC_ON_STACK
1123 h->cabac.range = cc.range ;
1124 h->cabac.low = cc.low ;
1125 h->cabac.bytestream= cc.bytestream;
1126 #endif
1127 return;
1128 }
1129 }
1130
1131 significant_coeff_ctx_base = h->cabac_state
1132 + significant_coeff_flag_offset[MB_FIELD][cat];
1133 last_coeff_ctx_base = h->cabac_state
1134 + last_coeff_flag_offset[MB_FIELD][cat];
1135 abs_level_m1_ctx_base = h->cabac_state
1136 + coeff_abs_level_m1_offset[cat];
1137
1138 if( !is_dc && cat == 5 ) {
1139 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1140 for(last= 0; last < coefs; last++) { \
1141 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1142 if( get_cabac( CC, sig_ctx )) { \
1143 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1144 index[coeff_count++] = last; \
1145 if( get_cabac( CC, last_ctx ) ) { \
1146 last= max_coeff; \
1147 break; \
1148 } \
1149 } \
1150 }\
1151 if( last == max_coeff -1 ) {\
1152 index[coeff_count++] = last;\
1153 }
1154 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1155 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1156 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1157 } else {
1158 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1159 #else
1160 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1161 } else {
1162 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1163 #endif
1164 }
1165 assert(coeff_count > 0);
1166
1167 if( is_dc ) {
1168 if( cat == 0 )
1169 h->cbp_table[h->mb_xy] |= 0x100;
1170 else
1171 h->cbp_table[h->mb_xy] |= 0x40 << n;
1172 } else {
1173 if( cat == 5 )
1174 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1175 else {
1176 assert( cat == 1 || cat == 2 || cat == 4 );
1177 h->non_zero_count_cache[scan8[n]] = coeff_count;
1178 }
1179 }
1180
1181 do {
1182 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1183
1184 int j= scantable[index[--coeff_count]];
1185
1186 if( get_cabac( CC, ctx ) == 0 ) {
1187 node_ctx = coeff_abs_level_transition[0][node_ctx];
1188 if( is_dc ) {
1189 block[j] = get_cabac_bypass_sign( CC, -1);
1190 }else{
1191 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1192 }
1193 } else {
1194 int coeff_abs = 2;
1195 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1196 node_ctx = coeff_abs_level_transition[1][node_ctx];
1197
1198 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1199 coeff_abs++;
1200 }
1201
1202 if( coeff_abs >= 15 ) {
1203 int j = 0;
1204 while( get_cabac_bypass( CC ) ) {
1205 j++;
1206 }
1207
1208 coeff_abs=1;
1209 while( j-- ) {
1210 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1211 }
1212 coeff_abs+= 14;
1213 }
1214
1215 if( is_dc ) {
1216 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1217 }else{
1218 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1219 }
1220 }
1221 } while( coeff_count );
1222 #ifdef CABAC_ON_STACK
1223 h->cabac.range = cc.range ;
1224 h->cabac.low = cc.low ;
1225 h->cabac.bytestream= cc.bytestream;
1226 #endif
1227
1228 }
1229
1230 #if !CONFIG_SMALL
1231 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 ) {
1232 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1233 }
1234
1235 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 ) {
1236 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1237 }
1238 #endif
1239
1240 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1241 #if CONFIG_SMALL
1242 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1243 #else
1244 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1245 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1246 #endif
1247 }
1248
1249 static inline void compute_mb_neighbors(H264Context *h)
1250 {
1251 MpegEncContext * const s = &h->s;
1252 const int mb_xy = h->mb_xy;
1253 h->top_mb_xy = mb_xy - s->mb_stride;
1254 h->left_mb_xy[0] = mb_xy - 1;
1255 if(FRAME_MBAFF){
1256 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
1257 const int top_pair_xy = pair_xy - s->mb_stride;
1258 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1259 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1260 const int curr_mb_field_flag = MB_FIELD;
1261 const int bottom = (s->mb_y & 1);
1262
1263 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1264 h->top_mb_xy -= s->mb_stride;
1265 }
1266 if (!left_mb_field_flag == curr_mb_field_flag) {
1267 h->left_mb_xy[0] = pair_xy - 1;
1268 }
1269 } else if (FIELD_PICTURE) {
1270 h->top_mb_xy -= s->mb_stride;
1271 }
1272 return;
1273 }
1274
1275 /**
1276 * decodes a macroblock
1277 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1278 */
1279 int ff_h264_decode_mb_cabac(H264Context *h) {
1280 MpegEncContext * const s = &h->s;
1281 int mb_xy;
1282 int mb_type, partition_count, cbp = 0;
1283 int dct8x8_allowed= h->pps.transform_8x8_mode;
1284
1285 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1286
1287 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1288 if( h->slice_type_nos != FF_I_TYPE ) {
1289 int skip;
1290 /* a skipped mb needs the aff flag from the following mb */
1291 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1292 predict_field_decoding_flag(h);
1293 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1294 skip = h->next_mb_skipped;
1295 else
1296 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1297 /* read skip flags */
1298 if( skip ) {
1299 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1300 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1301 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1302 if(!h->next_mb_skipped)
1303 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1304 }
1305
1306 decode_mb_skip(h);
1307
1308 h->cbp_table[mb_xy] = 0;
1309 h->chroma_pred_mode_table[mb_xy] = 0;
1310 h->last_qscale_diff = 0;
1311
1312 return 0;
1313
1314 }
1315 }
1316 if(FRAME_MBAFF){
1317 if( (s->mb_y&1) == 0 )
1318 h->mb_mbaff =
1319 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1320 }
1321
1322 h->prev_mb_skipped = 0;
1323
1324 compute_mb_neighbors(h);
1325
1326 if( h->slice_type_nos == FF_B_TYPE ) {
1327 mb_type = decode_cabac_mb_type_b( h );
1328 if( mb_type < 23 ){
1329 partition_count= b_mb_type_info[mb_type].partition_count;
1330 mb_type= b_mb_type_info[mb_type].type;
1331 }else{
1332 mb_type -= 23;
1333 goto decode_intra_mb;
1334 }
1335 } else if( h->slice_type_nos == FF_P_TYPE ) {
1336 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1337 /* P-type */
1338 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1339 /* P_L0_D16x16, P_8x8 */
1340 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1341 } else {
1342 /* P_L0_D8x16, P_L0_D16x8 */
1343 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1344 }
1345 partition_count= p_mb_type_info[mb_type].partition_count;
1346 mb_type= p_mb_type_info[mb_type].type;
1347 } else {
1348 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1349 goto decode_intra_mb;
1350 }
1351 } else {
1352 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1353 if(h->slice_type == FF_SI_TYPE && mb_type)
1354 mb_type--;
1355 assert(h->slice_type_nos == FF_I_TYPE);
1356 decode_intra_mb:
1357 partition_count = 0;
1358 cbp= i_mb_type_info[mb_type].cbp;
1359 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1360 mb_type= i_mb_type_info[mb_type].type;
1361 }
1362 if(MB_FIELD)
1363 mb_type |= MB_TYPE_INTERLACED;
1364
1365 h->slice_table[ mb_xy ]= h->slice_num;
1366
1367 if(IS_INTRA_PCM(mb_type)) {
1368 const uint8_t *ptr;
1369
1370 // We assume these blocks are very rare so we do not optimize it.
1371 // FIXME The two following lines get the bitstream position in the cabac
1372 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1373 ptr= h->cabac.bytestream;
1374 if(h->cabac.low&0x1) ptr--;
1375 if(CABAC_BITS==16){
1376 if(h->cabac.low&0x1FF) ptr--;
1377 }
1378
1379 // The pixels are stored in the same order as levels in h->mb array.
1380 memcpy(h->mb, ptr, 256); ptr+=256;
1381 if(CHROMA){
1382 memcpy(h->mb+128, ptr, 128); ptr+=128;
1383 }
1384
1385 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1386
1387 // All blocks are present
1388 h->cbp_table[mb_xy] = 0x1ef;
1389 h->chroma_pred_mode_table[mb_xy] = 0;
1390 // In deblocking, the quantizer is 0
1391 s->current_picture.qscale_table[mb_xy]= 0;
1392 // All coeffs are present
1393 memset(h->non_zero_count[mb_xy], 16, 16);
1394 s->current_picture.mb_type[mb_xy]= mb_type;
1395 h->last_qscale_diff = 0;
1396 return 0;
1397 }
1398
1399 if(MB_MBAFF){
1400 h->ref_count[0] <<= 1;
1401 h->ref_count[1] <<= 1;
1402 }
1403
1404 fill_caches(h, mb_type, 0);
1405
1406 if( IS_INTRA( mb_type ) ) {
1407 int i, pred_mode;
1408 if( IS_INTRA4x4( mb_type ) ) {
1409 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
1410 mb_type |= MB_TYPE_8x8DCT;
1411 for( i = 0; i < 16; i+=4 ) {
1412 int pred = pred_intra_mode( h, i );
1413 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1414 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1415 }
1416 } else {
1417 for( i = 0; i < 16; i++ ) {
1418 int pred = pred_intra_mode( h, i );
1419 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1420
1421 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1422 }
1423 }
1424 ff_h264_write_back_intra_pred_mode(h);
1425 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1426 } else {
1427 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1428 if( h->intra16x16_pred_mode < 0 ) return -1;
1429 }
1430 if(CHROMA){
1431 h->chroma_pred_mode_table[mb_xy] =
1432 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1433
1434 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1435 if( pred_mode < 0 ) return -1;
1436 h->chroma_pred_mode= pred_mode;
1437 }
1438 } else if( partition_count == 4 ) {
1439 int i, j, sub_partition_count[4], list, ref[2][4];
1440
1441 if( h->slice_type_nos == FF_B_TYPE ) {
1442 for( i = 0; i < 4; i++ ) {
1443 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1444 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1445 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1446 }
1447 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1448 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1449 ff_h264_pred_direct_motion(h, &mb_type);
1450 h->ref_cache[0][scan8[4]] =
1451 h->ref_cache[1][scan8[4]] =
1452 h->ref_cache[0][scan8[12]] =
1453 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1454 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
1455 for( i = 0; i < 4; i++ )
1456 if( IS_DIRECT(h->sub_mb_type[i]) )
1457 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
1458 }
1459 }
1460 } else {
1461 for( i = 0; i < 4; i++ ) {
1462 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1463 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1464 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1465 }
1466 }
1467
1468 for( list = 0; list < h->list_count; list++ ) {
1469 for( i = 0; i < 4; i++ ) {
1470 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1471 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1472 if( h->ref_count[list] > 1 ){
1473 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1474 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1475 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1476 return -1;
1477 }
1478 }else
1479 ref[list][i] = 0;
1480 } else {
1481 ref[list][i] = -1;
1482 }
1483 h->ref_cache[list][ scan8[4*i]+1 ]=
1484 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1485 }
1486 }
1487
1488 if(dct8x8_allowed)
1489 dct8x8_allowed = get_dct8x8_allowed(h);
1490
1491 for(list=0; list<h->list_count; list++){
1492 for(i=0; i<4; i++){
1493 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1494 if(IS_DIRECT(h->sub_mb_type[i])){
1495 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1496 continue;
1497 }
1498
1499 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1500 const int sub_mb_type= h->sub_mb_type[i];
1501 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1502 for(j=0; j<sub_partition_count[i]; j++){
1503 int mpx, mpy;
1504 int mx, my;
1505 const int index= 4*i + block_width*j;
1506 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1507 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1508 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1509
1510 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1511 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1512 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1513
1514 if(IS_SUB_8X8(sub_mb_type)){
1515 mv_cache[ 1 ][0]=
1516 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1517 mv_cache[ 1 ][1]=
1518 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1519
1520 mvd_cache[ 1 ][0]=
1521 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1522 mvd_cache[ 1 ][1]=
1523 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1524 }else if(IS_SUB_8X4(sub_mb_type)){
1525 mv_cache[ 1 ][0]= mx;
1526 mv_cache[ 1 ][1]= my;
1527
1528 mvd_cache[ 1 ][0]= mx - mpx;
1529 mvd_cache[ 1 ][1]= my - mpy;
1530 }else if(IS_SUB_4X8(sub_mb_type)){
1531 mv_cache[ 8 ][0]= mx;
1532 mv_cache[ 8 ][1]= my;
1533
1534 mvd_cache[ 8 ][0]= mx - mpx;
1535 mvd_cache[ 8 ][1]= my - mpy;
1536 }
1537 mv_cache[ 0 ][0]= mx;
1538 mv_cache[ 0 ][1]= my;
1539
1540 mvd_cache[ 0 ][0]= mx - mpx;
1541 mvd_cache[ 0 ][1]= my - mpy;
1542 }
1543 }else{
1544 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1545 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1546 p[0] = p[1] = p[8] = p[9] = 0;
1547 pd[0]= pd[1]= pd[8]= pd[9]= 0;
1548 }
1549 }
1550 }
1551 } else if( IS_DIRECT(mb_type) ) {
1552 ff_h264_pred_direct_motion(h, &mb_type);
1553 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1554 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1555 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1556 } else {
1557 int list, mx, my, i, mpx, mpy;
1558 if(IS_16X16(mb_type)){
1559 for(list=0; list<h->list_count; list++){
1560 if(IS_DIR(mb_type, 0, list)){
1561 int ref;
1562 if(h->ref_count[list] > 1){
1563 ref= decode_cabac_mb_ref(h, list, 0);
1564 if(ref >= (unsigned)h->ref_count[list]){
1565 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1566 return -1;
1567 }
1568 }else
1569 ref=0;
1570 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1571 }else
1572 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
1573 }
1574 for(list=0; list<h->list_count; list++){
1575 if(IS_DIR(mb_type, 0, list)){
1576 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1577
1578 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1579 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1580 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1581
1582 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1583 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1584 }else
1585 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1586 }
1587 }
1588 else if(IS_16X8(mb_type)){
1589 for(list=0; list<h->list_count; list++){
1590 for(i=0; i<2; i++){
1591 if(IS_DIR(mb_type, i, list)){
1592 int ref;
1593 if(h->ref_count[list] > 1){
1594 ref= decode_cabac_mb_ref( h, list, 8*i );
1595 if(ref >= (unsigned)h->ref_count[list]){
1596 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1597 return -1;
1598 }
1599 }else
1600 ref=0;
1601 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1602 }else
1603 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1604 }
1605 }
1606 for(list=0; list<h->list_count; list++){
1607 for(i=0; i<2; i++){
1608 if(IS_DIR(mb_type, i, list)){
1609 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1610 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1611 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1612 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1613
1614 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1615 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1616 }else{
1617 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1618 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1619 }
1620 }
1621 }
1622 }else{
1623 assert(IS_8X16(mb_type));
1624 for(list=0; list<h->list_count; list++){
1625 for(i=0; i<2; i++){
1626 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1627 int ref;
1628 if(h->ref_count[list] > 1){
1629 ref= decode_cabac_mb_ref( h, list, 4*i );
1630 if(ref >= (unsigned)h->ref_count[list]){
1631 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1632 return -1;
1633 }
1634 }else
1635 ref=0;
1636 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1637 }else
1638 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1639 }
1640 }
1641 for(list=0; list<h->list_count; list++){
1642 for(i=0; i<2; i++){
1643 if(IS_DIR(mb_type, i, list)){
1644 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1645 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1646 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1647
1648 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1649 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1650 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1651 }else{
1652 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1653 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1654 }
1655 }
1656 }
1657 }
1658 }
1659
1660 if( IS_INTER( mb_type ) ) {
1661 h->chroma_pred_mode_table[mb_xy] = 0;
1662 write_back_motion( h, mb_type );
1663 }
1664
1665 if( !IS_INTRA16x16( mb_type ) ) {
1666 cbp = decode_cabac_mb_cbp_luma( h );
1667 if(CHROMA)
1668 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1669 }
1670
1671 h->cbp_table[mb_xy] = h->cbp = cbp;
1672
1673 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1674 if( decode_cabac_mb_transform_size( h ) )
1675 mb_type |= MB_TYPE_8x8DCT;
1676 }
1677 s->current_picture.mb_type[mb_xy]= mb_type;
1678
1679 if( cbp || IS_INTRA16x16( mb_type ) ) {
1680 const uint8_t *scan, *scan8x8, *dc_scan;
1681 const uint32_t *qmul;
1682 int dqp;
1683
1684 if(IS_INTERLACED(mb_type)){
1685 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1686 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1687 dc_scan= luma_dc_field_scan;
1688 }else{
1689 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1690 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1691 dc_scan= luma_dc_zigzag_scan;
1692 }
1693
1694 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
1695 if( dqp == INT_MIN ){
1696 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1697 return -1;
1698 }
1699 s->qscale += dqp;
1700 if(((unsigned)s->qscale) > 51){
1701 if(s->qscale<0) s->qscale+= 52;
1702 else s->qscale-= 52;
1703 }
1704 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1705 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1706
1707 if( IS_INTRA16x16( mb_type ) ) {
1708 int i;
1709 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1710 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1711
1712 if( cbp&15 ) {
1713 qmul = h->dequant4_coeff[0][s->qscale];
1714 for( i = 0; i < 16; i++ ) {
1715 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1716 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1717 }
1718 } else {
1719 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1720 }
1721 } else {
1722 int i8x8, i4x4;
1723 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1724 if( cbp & (1<<i8x8) ) {
1725 if( IS_8x8DCT(mb_type) ) {
1726 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1727 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1728 } else {
1729 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1730 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1731 const int index = 4*i8x8 + i4x4;
1732 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1733 //START_TIMER
1734 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1735 //STOP_TIMER("decode_residual")
1736 }
1737 }
1738 } else {
1739 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1740 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1741 }
1742 }
1743 }
1744
1745 if( cbp&0x30 ){
1746 int c;
1747 for( c = 0; c < 2; c++ ) {
1748 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1749 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1750 }
1751 }
1752
1753 if( cbp&0x20 ) {
1754 int c, i;
1755 for( c = 0; c < 2; c++ ) {
1756 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1757 for( i = 0; i < 4; i++ ) {
1758 const int index = 16 + 4 * c + i;
1759 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1760 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1761 }
1762 }
1763 } else {
1764 uint8_t * const nnz= &h->non_zero_count_cache[0];
1765 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1766 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1767 }
1768 } else {
1769 uint8_t * const nnz= &h->non_zero_count_cache[0];
1770 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1771 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1772 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1773 h->last_qscale_diff = 0;
1774 }
1775
1776 s->current_picture.qscale_table[mb_xy]= s->qscale;
1777 write_back_non_zero_count(h);
1778
1779 if(MB_MBAFF){
1780 h->ref_count[0] >>= 1;
1781 h->ref_count[1] >>= 1;
1782 }
1783
1784 return 0;
1785 }