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