2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/h264_cabac.c
24 * H.264 / AVC / MPEG4 part10 cabac decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
35 #include "h264_mvpred.h"
40 #include "x86/h264_i386.h"
46 /* Cabac pre state table */
48 static const int8_t cabac_context_init_I[460][2] =
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 },
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 },
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 },
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 },
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
80 { 13, 41 }, { 3, 62 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
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 },
153 /* 276 a bit special (not used, bypass is used instead) */
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 },
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 },
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 },
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 },
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 },
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 }
217 static const int8_t cabac_context_init_PB[3][460][2] =
219 /* i_cabac_init_idc == 0 */
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 },
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 },
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 },
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 },
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
246 { -7, 72 }, { 1, 58 },
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
251 { 13, 41 }, { 3, 62 },
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 },
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 },
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 },
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 },
315 /* 276 a bit special (not used, bypass is used instead) */
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 },
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 },
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 },
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 },
375 /* i_cabac_init_idc == 1 */
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 },
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 },
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 },
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 },
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
402 { -5, 72 },{ 0, 61 },
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
407 { 13, 41 }, { 3, 62 },
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 },
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 },
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 },
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 },
471 /* 276 a bit special (not used, bypass is used instead) */
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 },
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 },
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 },
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 },
531 /* i_cabac_init_idc == 2 */
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 },
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 },
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 },
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 },
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
558 { -7, 50 },{ 1, 60 },
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
563 { 13, 41 }, { 3, 62 },
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 },
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 },
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 },
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 },
627 /* 276 a bit special (not used, bypass is used instead) */
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 },
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 },
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 },
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 },
688 void ff_h264_init_cabac_states(H264Context *h) {
689 MpegEncContext * const s = &h->s;
691 const int8_t (*tab)[2];
693 if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
694 else tab = cabac_context_init_PB[h->cabac_init_idc];
696 /* calculate pre-state */
697 for( i= 0; i < 460; i++ ) {
698 int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
704 h->cabac_state[i] = pre;
708 static int decode_cabac_field_decoding_flag(H264Context *h) {
709 MpegEncContext * const s = &h->s;
710 const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
712 unsigned long ctx = 0;
714 ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
715 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
721 uint8_t *state= &h->cabac_state[ctx_base];
726 if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
728 if( h->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
730 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
734 if( get_cabac_noinline( &h->cabac, state ) == 0 )
738 if( get_cabac_terminate( &h->cabac ) )
741 mb_type = 1; /* I16x16 */
742 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
743 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
744 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
745 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
746 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
751 MpegEncContext * const s = &h->s;
755 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
756 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
759 && h->slice_table[mba_xy] == h->slice_num
760 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
761 mba_xy += s->mb_stride;
763 mbb_xy = mb_xy - s->mb_stride;
765 && h->slice_table[mbb_xy] == h->slice_num
766 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
767 mbb_xy -= s->mb_stride;
769 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
771 int mb_xy = h->mb_xy;
773 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
776 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
778 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
781 if( h->slice_type_nos == FF_B_TYPE )
783 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
789 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
792 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
793 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
794 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
796 return mode + ( mode >= pred_mode );
799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
800 const int mba_xy = h->left_mb_xy[0];
801 const int mbb_xy = h->top_mb_xy;
805 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
806 if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
809 if( h->top_type && h->chroma_pred_mode_table[mbb_xy] != 0 )
812 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
815 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
817 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
823 static int decode_cabac_mb_cbp_luma( H264Context *h) {
824 int cbp_b, cbp_a, ctx, cbp = 0;
829 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
830 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
831 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08);
832 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
833 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01);
834 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
835 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02);
836 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
839 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
843 cbp_a = (h->left_cbp>>4)&0x03;
844 cbp_b = (h-> top_cbp>>4)&0x03;
847 if( cbp_a > 0 ) ctx++;
848 if( cbp_b > 0 ) ctx += 2;
849 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
853 if( cbp_a == 2 ) ctx++;
854 if( cbp_b == 2 ) ctx += 2;
855 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
858 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
859 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
861 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
863 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
867 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
869 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
870 return 0; /* B_Direct_8x8 */
871 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
872 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
874 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
875 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
876 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
879 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
880 type += get_cabac( &h->cabac, &h->cabac_state[39] );
884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
885 int refa = h->ref_cache[list][scan8[n] - 1];
886 int refb = h->ref_cache[list][scan8[n] - 8];
890 if( h->slice_type_nos == FF_B_TYPE) {
891 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
893 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
902 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
905 if(ref >= 32 /*h->ref_list[list]*/){
912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
915 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
916 // if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
923 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
931 while( get_cabac_bypass( &h->cabac ) ) {
935 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
940 mvd += get_cabac_bypass( &h->cabac )<<k;
942 *mvda=mvd < 70 ? mvd : 70;
945 return get_cabac_bypass_sign( &h->cabac, -mvd );
948 #define DECODE_CABAC_MB_MVD( h, list, n )\
950 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
951 h->mvd_cache[list][scan8[n] - 8][0];\
952 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
953 h->mvd_cache[list][scan8[n] - 8][1];\
955 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
956 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
965 nza = h->left_cbp&0x100;
966 nzb = h-> top_cbp&0x100;
968 nza = (h->left_cbp>>(6+idx))&0x01;
969 nzb = (h-> top_cbp>>(6+idx))&0x01;
972 assert(cat == 1 || cat == 2 || cat == 4);
973 nza = h->non_zero_count_cache[scan8[idx] - 1];
974 nzb = h->non_zero_count_cache[scan8[idx] - 8];
983 return ctx + 4 * cat;
986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
987 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
988 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
989 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
990 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
993 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 ) {
994 static const int significant_coeff_flag_offset[2][6] = {
995 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
996 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
998 static const int last_coeff_flag_offset[2][6] = {
999 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1000 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1002 static const int coeff_abs_level_m1_offset[6] = {
1003 227+0, 227+10, 227+20, 227+30, 227+39, 426
1005 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1006 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1007 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1008 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1009 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1010 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1011 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1012 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1013 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1015 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1016 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1017 * map node ctx => cabac ctx for level=1 */
1018 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1019 /* map node ctx => cabac ctx for level>1 */
1020 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1021 static const uint8_t coeff_abs_level_transition[2][8] = {
1022 /* update node ctx after decoding a level=1 */
1023 { 1, 2, 3, 3, 4, 5, 6, 7 },
1024 /* update node ctx after decoding a level>1 */
1025 { 4, 4, 4, 4, 5, 6, 7, 7 }
1031 int coeff_count = 0;
1034 uint8_t *significant_coeff_ctx_base;
1035 uint8_t *last_coeff_ctx_base;
1036 uint8_t *abs_level_m1_ctx_base;
1039 #define CABAC_ON_STACK
1041 #ifdef CABAC_ON_STACK
1044 cc.range = h->cabac.range;
1045 cc.low = h->cabac.low;
1046 cc.bytestream= h->cabac.bytestream;
1048 #define CC &h->cabac
1052 /* cat: 0-> DC 16x16 n = 0
1053 * 1-> AC 16x16 n = luma4x4idx
1054 * 2-> Luma4x4 n = luma4x4idx
1055 * 3-> DC Chroma n = iCbCr
1056 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1057 * 5-> Luma8x8 n = 4 * luma8x8idx
1060 /* read coded block flag */
1061 if( is_dc || cat != 5 ) {
1062 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1064 h->non_zero_count_cache[scan8[n]] = 0;
1066 #ifdef CABAC_ON_STACK
1067 h->cabac.range = cc.range ;
1068 h->cabac.low = cc.low ;
1069 h->cabac.bytestream= cc.bytestream;
1075 significant_coeff_ctx_base = h->cabac_state
1076 + significant_coeff_flag_offset[MB_FIELD][cat];
1077 last_coeff_ctx_base = h->cabac_state
1078 + last_coeff_flag_offset[MB_FIELD][cat];
1079 abs_level_m1_ctx_base = h->cabac_state
1080 + coeff_abs_level_m1_offset[cat];
1082 if( !is_dc && cat == 5 ) {
1083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1084 for(last= 0; last < coefs; last++) { \
1085 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1086 if( get_cabac( CC, sig_ctx )) { \
1087 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1088 index[coeff_count++] = last; \
1089 if( get_cabac( CC, last_ctx ) ) { \
1095 if( last == max_coeff -1 ) {\
1096 index[coeff_count++] = last;\
1098 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1100 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1102 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1104 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1106 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1109 assert(coeff_count > 0);
1113 h->cbp_table[h->mb_xy] |= 0x100;
1115 h->cbp_table[h->mb_xy] |= 0x40 << n;
1118 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1120 assert( cat == 1 || cat == 2 || cat == 4 );
1121 h->non_zero_count_cache[scan8[n]] = coeff_count;
1126 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1128 int j= scantable[index[--coeff_count]];
1130 if( get_cabac( CC, ctx ) == 0 ) {
1131 node_ctx = coeff_abs_level_transition[0][node_ctx];
1133 block[j] = get_cabac_bypass_sign( CC, -1);
1135 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1139 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1140 node_ctx = coeff_abs_level_transition[1][node_ctx];
1142 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1146 if( coeff_abs >= 15 ) {
1148 while( get_cabac_bypass( CC ) ) {
1154 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1160 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1162 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1165 } while( coeff_count );
1166 #ifdef CABAC_ON_STACK
1167 h->cabac.range = cc.range ;
1168 h->cabac.low = cc.low ;
1169 h->cabac.bytestream= cc.bytestream;
1175 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 ) {
1176 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1179 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 ) {
1180 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1184 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1186 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1188 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1189 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1194 * decodes a macroblock
1195 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1197 int ff_h264_decode_mb_cabac(H264Context *h) {
1198 MpegEncContext * const s = &h->s;
1200 int mb_type, partition_count, cbp = 0;
1201 int dct8x8_allowed= h->pps.transform_8x8_mode;
1203 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1205 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1206 if( h->slice_type_nos != FF_I_TYPE ) {
1208 /* a skipped mb needs the aff flag from the following mb */
1209 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1210 skip = h->next_mb_skipped;
1212 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1213 /* read skip flags */
1215 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1216 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1217 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1218 if(!h->next_mb_skipped)
1219 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1224 h->cbp_table[mb_xy] = 0;
1225 h->chroma_pred_mode_table[mb_xy] = 0;
1226 h->last_qscale_diff = 0;
1233 if( (s->mb_y&1) == 0 )
1235 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1238 h->prev_mb_skipped = 0;
1240 fill_decode_neighbors(h, -(MB_FIELD));
1242 if( h->slice_type_nos == FF_B_TYPE ) {
1244 assert(h->slice_type_nos == FF_B_TYPE);
1246 if( !IS_DIRECT( h->left_type[0]-1 ) )
1248 if( !IS_DIRECT( h->top_type-1 ) )
1251 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1252 mb_type= 0; /* B_Direct_16x16 */
1253 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1254 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1257 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1258 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1259 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1260 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1262 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1263 }else if( bits == 13 ){
1264 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1265 goto decode_intra_mb;
1266 }else if( bits == 14 ){
1267 mb_type= 11; /* B_L1_L0_8x16 */
1268 }else if( bits == 15 ){
1269 mb_type= 22; /* B_8x8 */
1271 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1272 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1275 partition_count= b_mb_type_info[mb_type].partition_count;
1276 mb_type= b_mb_type_info[mb_type].type;
1277 } else if( h->slice_type_nos == FF_P_TYPE ) {
1278 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1280 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1281 /* P_L0_D16x16, P_8x8 */
1282 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1284 /* P_L0_D8x16, P_L0_D16x8 */
1285 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1287 partition_count= p_mb_type_info[mb_type].partition_count;
1288 mb_type= p_mb_type_info[mb_type].type;
1290 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1291 goto decode_intra_mb;
1294 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1295 if(h->slice_type == FF_SI_TYPE && mb_type)
1297 assert(h->slice_type_nos == FF_I_TYPE);
1299 partition_count = 0;
1300 cbp= i_mb_type_info[mb_type].cbp;
1301 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1302 mb_type= i_mb_type_info[mb_type].type;
1305 mb_type |= MB_TYPE_INTERLACED;
1307 h->slice_table[ mb_xy ]= h->slice_num;
1309 if(IS_INTRA_PCM(mb_type)) {
1312 // We assume these blocks are very rare so we do not optimize it.
1313 // FIXME The two following lines get the bitstream position in the cabac
1314 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1315 ptr= h->cabac.bytestream;
1316 if(h->cabac.low&0x1) ptr--;
1318 if(h->cabac.low&0x1FF) ptr--;
1321 // The pixels are stored in the same order as levels in h->mb array.
1322 memcpy(h->mb, ptr, 256); ptr+=256;
1324 memcpy(h->mb+128, ptr, 128); ptr+=128;
1327 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1329 // All blocks are present
1330 h->cbp_table[mb_xy] = 0x1ef;
1331 h->chroma_pred_mode_table[mb_xy] = 0;
1332 // In deblocking, the quantizer is 0
1333 s->current_picture.qscale_table[mb_xy]= 0;
1334 // All coeffs are present
1335 memset(h->non_zero_count[mb_xy], 16, 32);
1336 s->current_picture.mb_type[mb_xy]= mb_type;
1337 h->last_qscale_diff = 0;
1342 h->ref_count[0] <<= 1;
1343 h->ref_count[1] <<= 1;
1346 fill_decode_caches(h, mb_type);
1348 if( IS_INTRA( mb_type ) ) {
1350 if( IS_INTRA4x4( mb_type ) ) {
1351 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1352 mb_type |= MB_TYPE_8x8DCT;
1353 for( i = 0; i < 16; i+=4 ) {
1354 int pred = pred_intra_mode( h, i );
1355 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1356 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1359 for( i = 0; i < 16; i++ ) {
1360 int pred = pred_intra_mode( h, i );
1361 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1363 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1366 ff_h264_write_back_intra_pred_mode(h);
1367 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1369 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1370 if( h->intra16x16_pred_mode < 0 ) return -1;
1373 h->chroma_pred_mode_table[mb_xy] =
1374 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1376 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1377 if( pred_mode < 0 ) return -1;
1378 h->chroma_pred_mode= pred_mode;
1380 } else if( partition_count == 4 ) {
1381 int i, j, sub_partition_count[4], list, ref[2][4];
1383 if( h->slice_type_nos == FF_B_TYPE ) {
1384 for( i = 0; i < 4; i++ ) {
1385 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1386 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1387 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1389 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1390 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1391 ff_h264_pred_direct_motion(h, &mb_type);
1392 h->ref_cache[0][scan8[4]] =
1393 h->ref_cache[1][scan8[4]] =
1394 h->ref_cache[0][scan8[12]] =
1395 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1396 for( i = 0; i < 4; i++ )
1397 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1400 for( i = 0; i < 4; i++ ) {
1401 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1402 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1403 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1407 for( list = 0; list < h->list_count; list++ ) {
1408 for( i = 0; i < 4; i++ ) {
1409 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1410 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1411 if( h->ref_count[list] > 1 ){
1412 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1413 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1414 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1422 h->ref_cache[list][ scan8[4*i]+1 ]=
1423 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1428 dct8x8_allowed = get_dct8x8_allowed(h);
1430 for(list=0; list<h->list_count; list++){
1432 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1433 if(IS_DIRECT(h->sub_mb_type[i])){
1434 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1438 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1439 const int sub_mb_type= h->sub_mb_type[i];
1440 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1441 for(j=0; j<sub_partition_count[i]; j++){
1444 const int index= 4*i + block_width*j;
1445 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1446 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1447 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1448 DECODE_CABAC_MB_MVD( h, list, index)
1449 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1451 if(IS_SUB_8X8(sub_mb_type)){
1453 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1455 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1458 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1460 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1461 }else if(IS_SUB_8X4(sub_mb_type)){
1462 mv_cache[ 1 ][0]= mx;
1463 mv_cache[ 1 ][1]= my;
1465 mvd_cache[ 1 ][0]= mpx;
1466 mvd_cache[ 1 ][1]= mpy;
1467 }else if(IS_SUB_4X8(sub_mb_type)){
1468 mv_cache[ 8 ][0]= mx;
1469 mv_cache[ 8 ][1]= my;
1471 mvd_cache[ 8 ][0]= mpx;
1472 mvd_cache[ 8 ][1]= mpy;
1474 mv_cache[ 0 ][0]= mx;
1475 mv_cache[ 0 ][1]= my;
1477 mvd_cache[ 0 ][0]= mpx;
1478 mvd_cache[ 0 ][1]= mpy;
1481 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1482 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1486 } else if( IS_DIRECT(mb_type) ) {
1487 ff_h264_pred_direct_motion(h, &mb_type);
1488 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1489 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1490 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1493 if(IS_16X16(mb_type)){
1494 for(list=0; list<h->list_count; list++){
1495 if(IS_DIR(mb_type, 0, list)){
1497 if(h->ref_count[list] > 1){
1498 ref= decode_cabac_mb_ref(h, list, 0);
1499 if(ref >= (unsigned)h->ref_count[list]){
1500 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1505 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1507 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
1509 for(list=0; list<h->list_count; list++){
1510 if(IS_DIR(mb_type, 0, list)){
1512 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1513 DECODE_CABAC_MB_MVD( h, list, 0)
1514 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1516 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1517 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1519 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1522 else if(IS_16X8(mb_type)){
1523 for(list=0; list<h->list_count; list++){
1525 if(IS_DIR(mb_type, i, list)){
1527 if(h->ref_count[list] > 1){
1528 ref= decode_cabac_mb_ref( h, list, 8*i );
1529 if(ref >= (unsigned)h->ref_count[list]){
1530 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1535 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1537 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1540 for(list=0; list<h->list_count; list++){
1542 if(IS_DIR(mb_type, i, list)){
1544 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1545 DECODE_CABAC_MB_MVD( h, list, 8*i)
1546 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1548 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1549 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1551 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1552 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1557 assert(IS_8X16(mb_type));
1558 for(list=0; list<h->list_count; list++){
1560 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1562 if(h->ref_count[list] > 1){
1563 ref= decode_cabac_mb_ref( h, list, 4*i );
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]);
1570 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1572 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1575 for(list=0; list<h->list_count; list++){
1577 if(IS_DIR(mb_type, i, list)){
1579 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1580 DECODE_CABAC_MB_MVD( h, list, 4*i)
1582 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1583 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1584 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1586 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1587 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1594 if( IS_INTER( mb_type ) ) {
1595 h->chroma_pred_mode_table[mb_xy] = 0;
1596 write_back_motion( h, mb_type );
1599 if( !IS_INTRA16x16( mb_type ) ) {
1600 cbp = decode_cabac_mb_cbp_luma( h );
1602 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1605 h->cbp_table[mb_xy] = h->cbp = cbp;
1607 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1608 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1610 s->current_picture.mb_type[mb_xy]= mb_type;
1612 if( cbp || IS_INTRA16x16( mb_type ) ) {
1613 const uint8_t *scan, *scan8x8, *dc_scan;
1614 const uint32_t *qmul;
1616 if(IS_INTERLACED(mb_type)){
1617 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1618 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1619 dc_scan= luma_dc_field_scan;
1621 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1622 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1623 dc_scan= luma_dc_zigzag_scan;
1626 // decode_cabac_mb_dqp
1627 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1631 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1634 if(val > 102){ //prevent infinite loop
1635 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1643 val= -((val + 1)>>1);
1644 h->last_qscale_diff = val;
1646 if(((unsigned)s->qscale) > 51){
1647 if(s->qscale<0) s->qscale+= 52;
1648 else s->qscale-= 52;
1650 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1651 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1653 h->last_qscale_diff=0;
1655 if( IS_INTRA16x16( mb_type ) ) {
1657 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1658 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1661 qmul = h->dequant4_coeff[0][s->qscale];
1662 for( i = 0; i < 16; i++ ) {
1663 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1664 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1667 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1671 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1672 if( cbp & (1<<i8x8) ) {
1673 if( IS_8x8DCT(mb_type) ) {
1674 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1675 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1677 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1678 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1679 const int index = 4*i8x8 + i4x4;
1680 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1682 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1683 //STOP_TIMER("decode_residual")
1687 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1688 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1695 for( c = 0; c < 2; c++ ) {
1696 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1697 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1703 for( c = 0; c < 2; c++ ) {
1704 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1705 for( i = 0; i < 4; i++ ) {
1706 const int index = 16 + 4 * c + i;
1707 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1708 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1712 uint8_t * const nnz= &h->non_zero_count_cache[0];
1713 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1714 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1717 uint8_t * const nnz= &h->non_zero_count_cache[0];
1718 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1719 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1720 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1721 h->last_qscale_diff = 0;
1724 s->current_picture.qscale_table[mb_xy]= s->qscale;
1725 write_back_non_zero_count(h);
1728 h->ref_count[0] >>= 1;
1729 h->ref_count[1] >>= 1;