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
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 idx -= CHROMA_DC_BLOCK_INDEX;
969 nza = (h->left_cbp>>(6+idx))&0x01;
970 nzb = (h-> top_cbp>>(6+idx))&0x01;
973 assert(cat == 1 || cat == 2 || cat == 4);
974 nza = h->non_zero_count_cache[scan8[idx] - 1];
975 nzb = h->non_zero_count_cache[scan8[idx] - 8];
984 return ctx + 4 * cat;
987 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
988 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
989 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
990 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
991 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
994 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 ) {
995 static const int significant_coeff_flag_offset[2][6] = {
996 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
997 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
999 static const int last_coeff_flag_offset[2][6] = {
1000 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1001 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1003 static const int coeff_abs_level_m1_offset[6] = {
1004 227+0, 227+10, 227+20, 227+30, 227+39, 426
1006 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1007 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1008 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1009 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1010 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1011 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1012 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1013 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1014 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1016 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1017 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1018 * map node ctx => cabac ctx for level=1 */
1019 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1020 /* map node ctx => cabac ctx for level>1 */
1021 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1022 static const uint8_t coeff_abs_level_transition[2][8] = {
1023 /* update node ctx after decoding a level=1 */
1024 { 1, 2, 3, 3, 4, 5, 6, 7 },
1025 /* update node ctx after decoding a level>1 */
1026 { 4, 4, 4, 4, 5, 6, 7, 7 }
1032 int coeff_count = 0;
1035 uint8_t *significant_coeff_ctx_base;
1036 uint8_t *last_coeff_ctx_base;
1037 uint8_t *abs_level_m1_ctx_base;
1040 #define CABAC_ON_STACK
1042 #ifdef CABAC_ON_STACK
1045 cc.range = h->cabac.range;
1046 cc.low = h->cabac.low;
1047 cc.bytestream= h->cabac.bytestream;
1049 #define CC &h->cabac
1052 significant_coeff_ctx_base = h->cabac_state
1053 + significant_coeff_flag_offset[MB_FIELD][cat];
1054 last_coeff_ctx_base = h->cabac_state
1055 + last_coeff_flag_offset[MB_FIELD][cat];
1056 abs_level_m1_ctx_base = h->cabac_state
1057 + coeff_abs_level_m1_offset[cat];
1059 if( !is_dc && cat == 5 ) {
1060 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1061 for(last= 0; last < coefs; last++) { \
1062 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1063 if( get_cabac( CC, sig_ctx )) { \
1064 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1065 index[coeff_count++] = last; \
1066 if( get_cabac( CC, last_ctx ) ) { \
1072 if( last == max_coeff -1 ) {\
1073 index[coeff_count++] = last;\
1075 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1076 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1077 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1079 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1081 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1083 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1086 assert(coeff_count > 0);
1090 h->cbp_table[h->mb_xy] |= 0x100;
1092 h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
1093 h->non_zero_count_cache[scan8[n]] = coeff_count;
1096 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1098 assert( cat == 1 || cat == 2 || cat == 4 );
1099 h->non_zero_count_cache[scan8[n]] = coeff_count;
1104 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1106 int j= scantable[index[--coeff_count]];
1108 if( get_cabac( CC, ctx ) == 0 ) {
1109 node_ctx = coeff_abs_level_transition[0][node_ctx];
1111 block[j] = get_cabac_bypass_sign( CC, -1);
1113 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1117 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1118 node_ctx = coeff_abs_level_transition[1][node_ctx];
1120 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1124 if( coeff_abs >= 15 ) {
1126 while( get_cabac_bypass( CC ) ) {
1132 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1138 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1140 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1143 } while( coeff_count );
1144 #ifdef CABAC_ON_STACK
1145 h->cabac.range = cc.range ;
1146 h->cabac.low = cc.low ;
1147 h->cabac.bytestream= cc.bytestream;
1152 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1153 decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1156 static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1157 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1160 /* cat: 0-> DC 16x16 n = 0
1161 * 1-> AC 16x16 n = luma4x4idx
1162 * 2-> Luma4x4 n = luma4x4idx
1163 * 3-> DC Chroma n = iCbCr
1164 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1165 * 5-> Luma8x8 n = 4 * luma8x8idx */
1167 /* Partially inline the CABAC residual decode: inline the coded block flag.
1168 * This has very little impact on binary size and improves performance
1169 * because it allows improved constant propagation into get_cabac_cbf_ctx,
1170 * as well as because most blocks have zero CBFs. */
1172 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1173 /* read coded block flag */
1174 if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1175 h->non_zero_count_cache[scan8[n]] = 0;
1178 decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1181 static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1182 /* read coded block flag */
1183 if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1184 h->non_zero_count_cache[scan8[n]] = 0;
1187 decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1191 * decodes a macroblock
1192 * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1194 int ff_h264_decode_mb_cabac(H264Context *h) {
1195 MpegEncContext * const s = &h->s;
1197 int mb_type, partition_count, cbp = 0;
1198 int dct8x8_allowed= h->pps.transform_8x8_mode;
1200 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1202 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1203 if( h->slice_type_nos != FF_I_TYPE ) {
1205 /* a skipped mb needs the aff flag from the following mb */
1206 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1207 skip = h->next_mb_skipped;
1209 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1210 /* read skip flags */
1212 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1213 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1214 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1215 if(!h->next_mb_skipped)
1216 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1221 h->cbp_table[mb_xy] = 0;
1222 h->chroma_pred_mode_table[mb_xy] = 0;
1223 h->last_qscale_diff = 0;
1230 if( (s->mb_y&1) == 0 )
1232 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1235 h->prev_mb_skipped = 0;
1237 fill_decode_neighbors(h, -(MB_FIELD));
1239 if( h->slice_type_nos == FF_B_TYPE ) {
1241 assert(h->slice_type_nos == FF_B_TYPE);
1243 if( !IS_DIRECT( h->left_type[0]-1 ) )
1245 if( !IS_DIRECT( h->top_type-1 ) )
1248 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1249 mb_type= 0; /* B_Direct_16x16 */
1250 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1251 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1254 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1255 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1256 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1257 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1259 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1260 }else if( bits == 13 ){
1261 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1262 goto decode_intra_mb;
1263 }else if( bits == 14 ){
1264 mb_type= 11; /* B_L1_L0_8x16 */
1265 }else if( bits == 15 ){
1266 mb_type= 22; /* B_8x8 */
1268 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1269 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1272 partition_count= b_mb_type_info[mb_type].partition_count;
1273 mb_type= b_mb_type_info[mb_type].type;
1274 } else if( h->slice_type_nos == FF_P_TYPE ) {
1275 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1277 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1278 /* P_L0_D16x16, P_8x8 */
1279 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1281 /* P_L0_D8x16, P_L0_D16x8 */
1282 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1284 partition_count= p_mb_type_info[mb_type].partition_count;
1285 mb_type= p_mb_type_info[mb_type].type;
1287 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1288 goto decode_intra_mb;
1291 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1292 if(h->slice_type == FF_SI_TYPE && mb_type)
1294 assert(h->slice_type_nos == FF_I_TYPE);
1296 partition_count = 0;
1297 cbp= i_mb_type_info[mb_type].cbp;
1298 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1299 mb_type= i_mb_type_info[mb_type].type;
1302 mb_type |= MB_TYPE_INTERLACED;
1304 h->slice_table[ mb_xy ]= h->slice_num;
1306 if(IS_INTRA_PCM(mb_type)) {
1309 // We assume these blocks are very rare so we do not optimize it.
1310 // FIXME The two following lines get the bitstream position in the cabac
1311 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1312 ptr= h->cabac.bytestream;
1313 if(h->cabac.low&0x1) ptr--;
1315 if(h->cabac.low&0x1FF) ptr--;
1318 // The pixels are stored in the same order as levels in h->mb array.
1319 memcpy(h->mb, ptr, 256); ptr+=256;
1321 memcpy(h->mb+128, ptr, 128); ptr+=128;
1324 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1326 // All blocks are present
1327 h->cbp_table[mb_xy] = 0x1ef;
1328 h->chroma_pred_mode_table[mb_xy] = 0;
1329 // In deblocking, the quantizer is 0
1330 s->current_picture.qscale_table[mb_xy]= 0;
1331 // All coeffs are present
1332 memset(h->non_zero_count[mb_xy], 16, 32);
1333 s->current_picture.mb_type[mb_xy]= mb_type;
1334 h->last_qscale_diff = 0;
1339 h->ref_count[0] <<= 1;
1340 h->ref_count[1] <<= 1;
1343 fill_decode_caches(h, mb_type);
1345 if( IS_INTRA( mb_type ) ) {
1347 if( IS_INTRA4x4( mb_type ) ) {
1348 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1349 mb_type |= MB_TYPE_8x8DCT;
1350 for( i = 0; i < 16; i+=4 ) {
1351 int pred = pred_intra_mode( h, i );
1352 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1353 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1356 for( i = 0; i < 16; i++ ) {
1357 int pred = pred_intra_mode( h, i );
1358 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1360 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1363 ff_h264_write_back_intra_pred_mode(h);
1364 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1366 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1367 if( h->intra16x16_pred_mode < 0 ) return -1;
1370 h->chroma_pred_mode_table[mb_xy] =
1371 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1373 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1374 if( pred_mode < 0 ) return -1;
1375 h->chroma_pred_mode= pred_mode;
1377 h->chroma_pred_mode= DC_128_PRED8x8;
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);
1507 for(list=0; list<h->list_count; list++){
1508 if(IS_DIR(mb_type, 0, list)){
1510 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1511 DECODE_CABAC_MB_MVD( h, list, 0)
1512 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1514 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1515 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1519 else if(IS_16X8(mb_type)){
1520 for(list=0; list<h->list_count; list++){
1522 if(IS_DIR(mb_type, i, list)){
1524 if(h->ref_count[list] > 1){
1525 ref= decode_cabac_mb_ref( h, list, 8*i );
1526 if(ref >= (unsigned)h->ref_count[list]){
1527 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1532 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1534 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1537 for(list=0; list<h->list_count; list++){
1539 if(IS_DIR(mb_type, i, list)){
1541 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1542 DECODE_CABAC_MB_MVD( h, list, 8*i)
1543 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1545 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1546 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1548 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1549 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1554 assert(IS_8X16(mb_type));
1555 for(list=0; list<h->list_count; list++){
1557 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1559 if(h->ref_count[list] > 1){
1560 ref= decode_cabac_mb_ref( h, list, 4*i );
1561 if(ref >= (unsigned)h->ref_count[list]){
1562 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1567 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1569 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1572 for(list=0; list<h->list_count; list++){
1574 if(IS_DIR(mb_type, i, list)){
1576 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1577 DECODE_CABAC_MB_MVD( h, list, 4*i)
1579 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1580 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1581 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1583 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1584 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1591 if( IS_INTER( mb_type ) ) {
1592 h->chroma_pred_mode_table[mb_xy] = 0;
1593 write_back_motion( h, mb_type );
1596 if( !IS_INTRA16x16( mb_type ) ) {
1597 cbp = decode_cabac_mb_cbp_luma( h );
1599 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1602 h->cbp_table[mb_xy] = h->cbp = cbp;
1604 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1605 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1607 s->current_picture.mb_type[mb_xy]= mb_type;
1609 if( cbp || IS_INTRA16x16( mb_type ) ) {
1610 const uint8_t *scan, *scan8x8;
1611 const uint32_t *qmul;
1613 if(IS_INTERLACED(mb_type)){
1614 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1615 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1617 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1618 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1621 // decode_cabac_mb_dqp
1622 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1626 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1629 if(val > 102){ //prevent infinite loop
1630 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1638 val= -((val + 1)>>1);
1639 h->last_qscale_diff = val;
1641 if(((unsigned)s->qscale) > 51){
1642 if(s->qscale<0) s->qscale+= 52;
1643 else s->qscale-= 52;
1645 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1646 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1648 h->last_qscale_diff=0;
1650 if( IS_INTRA16x16( mb_type ) ) {
1652 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1653 AV_ZERO128(h->mb_luma_dc+0);
1654 AV_ZERO128(h->mb_luma_dc+8);
1655 decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1658 qmul = h->dequant4_coeff[0][s->qscale];
1659 for( i = 0; i < 16; i++ ) {
1660 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1661 decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1664 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1668 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1669 if( cbp & (1<<i8x8) ) {
1670 if( IS_8x8DCT(mb_type) ) {
1671 decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
1672 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1674 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1675 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1676 const int index = 4*i8x8 + i4x4;
1677 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1679 decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1680 //STOP_TIMER("decode_residual")
1684 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1685 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1692 for( c = 0; c < 2; c++ ) {
1693 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1694 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1700 for( c = 0; c < 2; c++ ) {
1701 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1702 for( i = 0; i < 4; i++ ) {
1703 const int index = 16 + 4 * c + i;
1704 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1705 decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1709 uint8_t * const nnz= &h->non_zero_count_cache[0];
1710 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1711 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1714 uint8_t * const nnz= &h->non_zero_count_cache[0];
1715 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1716 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1717 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1718 h->last_qscale_diff = 0;
1721 s->current_picture.qscale_table[mb_xy]= s->qscale;
1722 write_back_non_zero_count(h);
1725 h->ref_count[0] >>= 1;
1726 h->ref_count[1] >>= 1;