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>2)+(amvd>32)])){
922 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
930 while( get_cabac_bypass( &h->cabac ) ) {
934 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
939 mvd += get_cabac_bypass( &h->cabac )<<k;
941 *mvda=mvd < 70 ? mvd : 70;
944 return get_cabac_bypass_sign( &h->cabac, -mvd );
947 #define DECODE_CABAC_MB_MVD( h, list, n )\
949 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
950 h->mvd_cache[list][scan8[n] - 8][0];\
951 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
952 h->mvd_cache[list][scan8[n] - 8][1];\
954 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
955 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
958 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
964 nza = h->left_cbp&0x100;
965 nzb = h-> top_cbp&0x100;
967 nza = (h->left_cbp>>(6+idx))&0x01;
968 nzb = (h-> top_cbp>>(6+idx))&0x01;
971 assert(cat == 1 || cat == 2 || cat == 4);
972 nza = h->non_zero_count_cache[scan8[idx] - 1];
973 nzb = h->non_zero_count_cache[scan8[idx] - 8];
982 return ctx + 4 * cat;
985 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
986 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
987 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
988 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
989 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
992 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 ) {
993 static const int significant_coeff_flag_offset[2][6] = {
994 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
995 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
997 static const int last_coeff_flag_offset[2][6] = {
998 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
999 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1001 static const int coeff_abs_level_m1_offset[6] = {
1002 227+0, 227+10, 227+20, 227+30, 227+39, 426
1004 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1005 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1006 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1007 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1008 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1009 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1010 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1011 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1012 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1014 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1015 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1016 * map node ctx => cabac ctx for level=1 */
1017 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1018 /* map node ctx => cabac ctx for level>1 */
1019 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1020 static const uint8_t coeff_abs_level_transition[2][8] = {
1021 /* update node ctx after decoding a level=1 */
1022 { 1, 2, 3, 3, 4, 5, 6, 7 },
1023 /* update node ctx after decoding a level>1 */
1024 { 4, 4, 4, 4, 5, 6, 7, 7 }
1030 int coeff_count = 0;
1033 uint8_t *significant_coeff_ctx_base;
1034 uint8_t *last_coeff_ctx_base;
1035 uint8_t *abs_level_m1_ctx_base;
1038 #define CABAC_ON_STACK
1040 #ifdef CABAC_ON_STACK
1043 cc.range = h->cabac.range;
1044 cc.low = h->cabac.low;
1045 cc.bytestream= h->cabac.bytestream;
1047 #define CC &h->cabac
1051 /* cat: 0-> DC 16x16 n = 0
1052 * 1-> AC 16x16 n = luma4x4idx
1053 * 2-> Luma4x4 n = luma4x4idx
1054 * 3-> DC Chroma n = iCbCr
1055 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1056 * 5-> Luma8x8 n = 4 * luma8x8idx
1059 /* read coded block flag */
1060 if( is_dc || cat != 5 ) {
1061 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1063 h->non_zero_count_cache[scan8[n]] = 0;
1065 #ifdef CABAC_ON_STACK
1066 h->cabac.range = cc.range ;
1067 h->cabac.low = cc.low ;
1068 h->cabac.bytestream= cc.bytestream;
1074 significant_coeff_ctx_base = h->cabac_state
1075 + significant_coeff_flag_offset[MB_FIELD][cat];
1076 last_coeff_ctx_base = h->cabac_state
1077 + last_coeff_flag_offset[MB_FIELD][cat];
1078 abs_level_m1_ctx_base = h->cabac_state
1079 + coeff_abs_level_m1_offset[cat];
1081 if( !is_dc && cat == 5 ) {
1082 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1083 for(last= 0; last < coefs; last++) { \
1084 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1085 if( get_cabac( CC, sig_ctx )) { \
1086 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1087 index[coeff_count++] = last; \
1088 if( get_cabac( CC, last_ctx ) ) { \
1094 if( last == max_coeff -1 ) {\
1095 index[coeff_count++] = last;\
1097 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1098 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1099 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1101 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1103 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1105 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1108 assert(coeff_count > 0);
1112 h->cbp_table[h->mb_xy] |= 0x100;
1114 h->cbp_table[h->mb_xy] |= 0x40 << n;
1117 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1119 assert( cat == 1 || cat == 2 || cat == 4 );
1120 h->non_zero_count_cache[scan8[n]] = coeff_count;
1125 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1127 int j= scantable[index[--coeff_count]];
1129 if( get_cabac( CC, ctx ) == 0 ) {
1130 node_ctx = coeff_abs_level_transition[0][node_ctx];
1132 block[j] = get_cabac_bypass_sign( CC, -1);
1134 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1138 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1139 node_ctx = coeff_abs_level_transition[1][node_ctx];
1141 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1145 if( coeff_abs >= 15 ) {
1147 while( get_cabac_bypass( CC ) ) {
1153 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1159 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1161 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1164 } while( coeff_count );
1165 #ifdef CABAC_ON_STACK
1166 h->cabac.range = cc.range ;
1167 h->cabac.low = cc.low ;
1168 h->cabac.bytestream= cc.bytestream;
1174 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 ) {
1175 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1178 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 ) {
1179 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1183 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1185 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1187 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1188 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1193 * decodes a macroblock
1194 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1196 int ff_h264_decode_mb_cabac(H264Context *h) {
1197 MpegEncContext * const s = &h->s;
1199 int mb_type, partition_count, cbp = 0;
1200 int dct8x8_allowed= h->pps.transform_8x8_mode;
1202 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1204 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1205 if( h->slice_type_nos != FF_I_TYPE ) {
1207 /* a skipped mb needs the aff flag from the following mb */
1208 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1209 skip = h->next_mb_skipped;
1211 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1212 /* read skip flags */
1214 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1215 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1216 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1217 if(!h->next_mb_skipped)
1218 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1223 h->cbp_table[mb_xy] = 0;
1224 h->chroma_pred_mode_table[mb_xy] = 0;
1225 h->last_qscale_diff = 0;
1232 if( (s->mb_y&1) == 0 )
1234 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1237 h->prev_mb_skipped = 0;
1239 fill_decode_neighbors(h, -(MB_FIELD));
1241 if( h->slice_type_nos == FF_B_TYPE ) {
1243 assert(h->slice_type_nos == FF_B_TYPE);
1245 if( !IS_DIRECT( h->left_type[0]-1 ) )
1247 if( !IS_DIRECT( h->top_type-1 ) )
1250 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1251 mb_type= 0; /* B_Direct_16x16 */
1252 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1253 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1256 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1257 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1258 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1259 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1261 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1262 }else if( bits == 13 ){
1263 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1264 goto decode_intra_mb;
1265 }else if( bits == 14 ){
1266 mb_type= 11; /* B_L1_L0_8x16 */
1267 }else if( bits == 15 ){
1268 mb_type= 22; /* B_8x8 */
1270 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1271 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1274 partition_count= b_mb_type_info[mb_type].partition_count;
1275 mb_type= b_mb_type_info[mb_type].type;
1276 } else if( h->slice_type_nos == FF_P_TYPE ) {
1277 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1279 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1280 /* P_L0_D16x16, P_8x8 */
1281 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1283 /* P_L0_D8x16, P_L0_D16x8 */
1284 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1286 partition_count= p_mb_type_info[mb_type].partition_count;
1287 mb_type= p_mb_type_info[mb_type].type;
1289 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1290 goto decode_intra_mb;
1293 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1294 if(h->slice_type == FF_SI_TYPE && mb_type)
1296 assert(h->slice_type_nos == FF_I_TYPE);
1298 partition_count = 0;
1299 cbp= i_mb_type_info[mb_type].cbp;
1300 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1301 mb_type= i_mb_type_info[mb_type].type;
1304 mb_type |= MB_TYPE_INTERLACED;
1306 h->slice_table[ mb_xy ]= h->slice_num;
1308 if(IS_INTRA_PCM(mb_type)) {
1311 // We assume these blocks are very rare so we do not optimize it.
1312 // FIXME The two following lines get the bitstream position in the cabac
1313 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1314 ptr= h->cabac.bytestream;
1315 if(h->cabac.low&0x1) ptr--;
1317 if(h->cabac.low&0x1FF) ptr--;
1320 // The pixels are stored in the same order as levels in h->mb array.
1321 memcpy(h->mb, ptr, 256); ptr+=256;
1323 memcpy(h->mb+128, ptr, 128); ptr+=128;
1326 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1328 // All blocks are present
1329 h->cbp_table[mb_xy] = 0x1ef;
1330 h->chroma_pred_mode_table[mb_xy] = 0;
1331 // In deblocking, the quantizer is 0
1332 s->current_picture.qscale_table[mb_xy]= 0;
1333 // All coeffs are present
1334 memset(h->non_zero_count[mb_xy], 16, 32);
1335 s->current_picture.mb_type[mb_xy]= mb_type;
1336 h->last_qscale_diff = 0;
1341 h->ref_count[0] <<= 1;
1342 h->ref_count[1] <<= 1;
1345 fill_decode_caches(h, mb_type);
1347 if( IS_INTRA( mb_type ) ) {
1349 if( IS_INTRA4x4( mb_type ) ) {
1350 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1351 mb_type |= MB_TYPE_8x8DCT;
1352 for( i = 0; i < 16; i+=4 ) {
1353 int pred = pred_intra_mode( h, i );
1354 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1355 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1358 for( i = 0; i < 16; i++ ) {
1359 int pred = pred_intra_mode( h, i );
1360 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1362 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1365 ff_h264_write_back_intra_pred_mode(h);
1366 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1368 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1369 if( h->intra16x16_pred_mode < 0 ) return -1;
1372 h->chroma_pred_mode_table[mb_xy] =
1373 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1375 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1376 if( pred_mode < 0 ) return -1;
1377 h->chroma_pred_mode= pred_mode;
1379 } else if( partition_count == 4 ) {
1380 int i, j, sub_partition_count[4], list, ref[2][4];
1382 if( h->slice_type_nos == FF_B_TYPE ) {
1383 for( i = 0; i < 4; i++ ) {
1384 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1385 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1386 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1388 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1389 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1390 ff_h264_pred_direct_motion(h, &mb_type);
1391 h->ref_cache[0][scan8[4]] =
1392 h->ref_cache[1][scan8[4]] =
1393 h->ref_cache[0][scan8[12]] =
1394 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1395 for( i = 0; i < 4; i++ )
1396 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1399 for( i = 0; i < 4; i++ ) {
1400 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1401 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1402 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1406 for( list = 0; list < h->list_count; list++ ) {
1407 for( i = 0; i < 4; i++ ) {
1408 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1409 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1410 if( h->ref_count[list] > 1 ){
1411 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1412 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1413 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1421 h->ref_cache[list][ scan8[4*i]+1 ]=
1422 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1427 dct8x8_allowed = get_dct8x8_allowed(h);
1429 for(list=0; list<h->list_count; list++){
1431 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1432 if(IS_DIRECT(h->sub_mb_type[i])){
1433 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1437 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1438 const int sub_mb_type= h->sub_mb_type[i];
1439 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1440 for(j=0; j<sub_partition_count[i]; j++){
1443 const int index= 4*i + block_width*j;
1444 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1445 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1446 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1447 DECODE_CABAC_MB_MVD( h, list, index)
1448 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1450 if(IS_SUB_8X8(sub_mb_type)){
1452 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1454 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1457 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1459 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1460 }else if(IS_SUB_8X4(sub_mb_type)){
1461 mv_cache[ 1 ][0]= mx;
1462 mv_cache[ 1 ][1]= my;
1464 mvd_cache[ 1 ][0]= mpx;
1465 mvd_cache[ 1 ][1]= mpy;
1466 }else if(IS_SUB_4X8(sub_mb_type)){
1467 mv_cache[ 8 ][0]= mx;
1468 mv_cache[ 8 ][1]= my;
1470 mvd_cache[ 8 ][0]= mpx;
1471 mvd_cache[ 8 ][1]= mpy;
1473 mv_cache[ 0 ][0]= mx;
1474 mv_cache[ 0 ][1]= my;
1476 mvd_cache[ 0 ][0]= mpx;
1477 mvd_cache[ 0 ][1]= mpy;
1480 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1481 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1485 } else if( IS_DIRECT(mb_type) ) {
1486 ff_h264_pred_direct_motion(h, &mb_type);
1487 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1488 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1489 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1492 if(IS_16X16(mb_type)){
1493 for(list=0; list<h->list_count; list++){
1494 if(IS_DIR(mb_type, 0, list)){
1496 if(h->ref_count[list] > 1){
1497 ref= decode_cabac_mb_ref(h, list, 0);
1498 if(ref >= (unsigned)h->ref_count[list]){
1499 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1504 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1506 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
1508 for(list=0; list<h->list_count; list++){
1509 if(IS_DIR(mb_type, 0, list)){
1511 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1512 DECODE_CABAC_MB_MVD( h, list, 0)
1513 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1515 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1516 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1518 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1521 else if(IS_16X8(mb_type)){
1522 for(list=0; list<h->list_count; list++){
1524 if(IS_DIR(mb_type, i, list)){
1526 if(h->ref_count[list] > 1){
1527 ref= decode_cabac_mb_ref( h, list, 8*i );
1528 if(ref >= (unsigned)h->ref_count[list]){
1529 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1534 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1536 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1539 for(list=0; list<h->list_count; list++){
1541 if(IS_DIR(mb_type, i, list)){
1543 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1544 DECODE_CABAC_MB_MVD( h, list, 8*i)
1545 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1547 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1548 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1550 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1551 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1556 assert(IS_8X16(mb_type));
1557 for(list=0; list<h->list_count; list++){
1559 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1561 if(h->ref_count[list] > 1){
1562 ref= decode_cabac_mb_ref( h, list, 4*i );
1563 if(ref >= (unsigned)h->ref_count[list]){
1564 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1569 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1571 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1574 for(list=0; list<h->list_count; list++){
1576 if(IS_DIR(mb_type, i, list)){
1578 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1579 DECODE_CABAC_MB_MVD( h, list, 4*i)
1581 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1582 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1583 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1585 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1586 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1593 if( IS_INTER( mb_type ) ) {
1594 h->chroma_pred_mode_table[mb_xy] = 0;
1595 write_back_motion( h, mb_type );
1598 if( !IS_INTRA16x16( mb_type ) ) {
1599 cbp = decode_cabac_mb_cbp_luma( h );
1601 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1604 h->cbp_table[mb_xy] = h->cbp = cbp;
1606 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1607 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1609 s->current_picture.mb_type[mb_xy]= mb_type;
1611 if( cbp || IS_INTRA16x16( mb_type ) ) {
1612 const uint8_t *scan, *scan8x8, *dc_scan;
1613 const uint32_t *qmul;
1615 if(IS_INTERLACED(mb_type)){
1616 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1617 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1618 dc_scan= luma_dc_field_scan;
1620 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1621 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1622 dc_scan= luma_dc_zigzag_scan;
1625 // decode_cabac_mb_dqp
1626 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1630 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1633 if(val > 102){ //prevent infinite loop
1634 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1642 val= -((val + 1)>>1);
1643 h->last_qscale_diff = val;
1645 if(((unsigned)s->qscale) > 51){
1646 if(s->qscale<0) s->qscale+= 52;
1647 else s->qscale-= 52;
1649 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1650 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1652 h->last_qscale_diff=0;
1654 if( IS_INTRA16x16( mb_type ) ) {
1656 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1657 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1660 qmul = h->dequant4_coeff[0][s->qscale];
1661 for( i = 0; i < 16; i++ ) {
1662 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1663 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1666 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1670 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1671 if( cbp & (1<<i8x8) ) {
1672 if( IS_8x8DCT(mb_type) ) {
1673 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1674 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1676 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1677 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1678 const int index = 4*i8x8 + i4x4;
1679 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1681 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1682 //STOP_TIMER("decode_residual")
1686 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1687 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1694 for( c = 0; c < 2; c++ ) {
1695 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1696 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1702 for( c = 0; c < 2; c++ ) {
1703 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1704 for( i = 0; i < 4; i++ ) {
1705 const int index = 16 + 4 * c + i;
1706 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1707 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1711 uint8_t * const nnz= &h->non_zero_count_cache[0];
1712 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1713 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1716 uint8_t * const nnz= &h->non_zero_count_cache[0];
1717 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1718 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1719 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1720 h->last_qscale_diff = 0;
1723 s->current_picture.qscale_table[mb_xy]= s->qscale;
1724 write_back_non_zero_count(h);
1727 h->ref_count[0] >>= 1;
1728 h->ref_count[1] >>= 1;