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];
692 const int slice_qp = av_clip(s->qscale - 6*(h->sps.bit_depth_luma-8), 0, 51);
694 if( h->slice_type_nos == AV_PICTURE_TYPE_I ) tab = cabac_context_init_I;
695 else tab = cabac_context_init_PB[h->cabac_init_idc];
697 /* calculate pre-state */
698 for( i= 0; i < 460; i++ ) {
699 int pre = 2*(((tab[i][0] * slice_qp) >>4 ) + tab[i][1]) - 127;
705 h->cabac_state[i] = pre;
709 static int decode_cabac_field_decoding_flag(H264Context *h) {
710 MpegEncContext * const s = &h->s;
711 const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
713 unsigned long ctx = 0;
715 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);
716 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
718 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
721 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
722 uint8_t *state= &h->cabac_state[ctx_base];
727 if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
729 if( h->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
731 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
735 if( get_cabac_noinline( &h->cabac, state ) == 0 )
739 if( get_cabac_terminate( &h->cabac ) )
742 mb_type = 1; /* I16x16 */
743 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
744 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
745 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
746 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
747 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
751 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
752 MpegEncContext * const s = &h->s;
756 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
757 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
760 && h->slice_table[mba_xy] == h->slice_num
761 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
762 mba_xy += s->mb_stride;
764 mbb_xy = mb_xy - s->mb_stride;
766 && h->slice_table[mbb_xy] == h->slice_num
767 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
768 mbb_xy -= s->mb_stride;
770 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
772 int mb_xy = h->mb_xy;
774 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
777 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
779 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
782 if( h->slice_type_nos == AV_PICTURE_TYPE_B )
784 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
787 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
790 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
793 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
794 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
795 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
797 return mode + ( mode >= pred_mode );
800 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
801 const int mba_xy = h->left_mb_xy[0];
802 const int mbb_xy = h->top_mb_xy;
806 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
807 if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
810 if( h->top_type && h->chroma_pred_mode_table[mbb_xy] != 0 )
813 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
816 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
818 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
824 static int decode_cabac_mb_cbp_luma( H264Context *h) {
825 int cbp_b, cbp_a, ctx, cbp = 0;
830 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
831 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
832 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08);
833 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
834 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01);
835 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
836 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02);
837 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
840 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
844 cbp_a = (h->left_cbp>>4)&0x03;
845 cbp_b = (h-> top_cbp>>4)&0x03;
848 if( cbp_a > 0 ) ctx++;
849 if( cbp_b > 0 ) ctx += 2;
850 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
854 if( cbp_a == 2 ) ctx++;
855 if( cbp_b == 2 ) ctx += 2;
856 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
859 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
860 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
862 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
864 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
868 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
870 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
871 return 0; /* B_Direct_8x8 */
872 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
873 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
875 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
876 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
877 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
880 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
881 type += get_cabac( &h->cabac, &h->cabac_state[39] );
885 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
886 int refa = h->ref_cache[list][scan8[n] - 1];
887 int refb = h->ref_cache[list][scan8[n] - 8];
891 if( h->slice_type_nos == AV_PICTURE_TYPE_B) {
892 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
894 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
903 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
906 if(ref >= 32 /*h->ref_list[list]*/){
913 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
916 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
917 // if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
924 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
932 while( get_cabac_bypass( &h->cabac ) ) {
936 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
941 mvd += get_cabac_bypass( &h->cabac )<<k;
943 *mvda=mvd < 70 ? mvd : 70;
946 return get_cabac_bypass_sign( &h->cabac, -mvd );
949 #define DECODE_CABAC_MB_MVD( h, list, n )\
951 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
952 h->mvd_cache[list][scan8[n] - 8][0];\
953 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
954 h->mvd_cache[list][scan8[n] - 8][1];\
956 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
957 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
960 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
966 nza = h->left_cbp&0x100;
967 nzb = h-> top_cbp&0x100;
969 idx -= CHROMA_DC_BLOCK_INDEX;
970 nza = (h->left_cbp>>(6+idx))&0x01;
971 nzb = (h-> top_cbp>>(6+idx))&0x01;
974 assert(cat == 1 || cat == 2 || cat == 4);
975 nza = h->non_zero_count_cache[scan8[idx] - 1];
976 nzb = h->non_zero_count_cache[scan8[idx] - 8];
985 return ctx + 4 * cat;
988 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
989 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
990 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
991 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
992 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
995 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 ) {
996 static const int significant_coeff_flag_offset[2][6] = {
997 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
998 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1000 static const int last_coeff_flag_offset[2][6] = {
1001 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1002 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1004 static const int coeff_abs_level_m1_offset[6] = {
1005 227+0, 227+10, 227+20, 227+30, 227+39, 426
1007 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1008 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1009 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1010 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1011 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1012 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1013 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1014 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1015 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1017 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1018 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1019 * map node ctx => cabac ctx for level=1 */
1020 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1021 /* map node ctx => cabac ctx for level>1 */
1022 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1023 static const uint8_t coeff_abs_level_transition[2][8] = {
1024 /* update node ctx after decoding a level=1 */
1025 { 1, 2, 3, 3, 4, 5, 6, 7 },
1026 /* update node ctx after decoding a level>1 */
1027 { 4, 4, 4, 4, 5, 6, 7, 7 }
1033 int coeff_count = 0;
1036 uint8_t *significant_coeff_ctx_base;
1037 uint8_t *last_coeff_ctx_base;
1038 uint8_t *abs_level_m1_ctx_base;
1041 #define CABAC_ON_STACK
1043 #ifdef CABAC_ON_STACK
1046 cc.range = h->cabac.range;
1047 cc.low = h->cabac.low;
1048 cc.bytestream= h->cabac.bytestream;
1050 #define CC &h->cabac
1053 significant_coeff_ctx_base = h->cabac_state
1054 + significant_coeff_flag_offset[MB_FIELD][cat];
1055 last_coeff_ctx_base = h->cabac_state
1056 + last_coeff_flag_offset[MB_FIELD][cat];
1057 abs_level_m1_ctx_base = h->cabac_state
1058 + coeff_abs_level_m1_offset[cat];
1060 if( !is_dc && cat == 5 ) {
1061 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1062 for(last= 0; last < coefs; last++) { \
1063 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1064 if( get_cabac( CC, sig_ctx )) { \
1065 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1066 index[coeff_count++] = last; \
1067 if( get_cabac( CC, last_ctx ) ) { \
1073 if( last == max_coeff -1 ) {\
1074 index[coeff_count++] = last;\
1076 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1077 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1078 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1080 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1082 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1084 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1087 assert(coeff_count > 0);
1091 h->cbp_table[h->mb_xy] |= 0x100;
1093 h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
1094 h->non_zero_count_cache[scan8[n]] = coeff_count;
1097 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1099 assert( cat == 1 || cat == 2 || cat == 4 );
1100 h->non_zero_count_cache[scan8[n]] = coeff_count;
1105 #define STORE_BLOCK(type) \
1107 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;\
1109 int j= scantable[index[--coeff_count]];\
1110 if( get_cabac( CC, ctx ) == 0 ) { \
1111 node_ctx = coeff_abs_level_transition[0][node_ctx]; \
1113 ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \
1115 ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
1118 int coeff_abs = 2; \
1119 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1120 node_ctx = coeff_abs_level_transition[1][node_ctx]; \
1122 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
1126 if( coeff_abs >= 15 ) { \
1128 while( get_cabac_bypass( CC ) ) { \
1134 coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
1140 ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \
1142 ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \
1145 } while( coeff_count );
1147 if (h->pixel_shift) {
1148 STORE_BLOCK(int32_t)
1150 STORE_BLOCK(int16_t)
1152 #ifdef CABAC_ON_STACK
1153 h->cabac.range = cc.range ;
1154 h->cabac.low = cc.low ;
1155 h->cabac.bytestream= cc.bytestream;
1160 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1161 decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1164 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 ) {
1165 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1168 /* cat: 0-> DC 16x16 n = 0
1169 * 1-> AC 16x16 n = luma4x4idx
1170 * 2-> Luma4x4 n = luma4x4idx
1171 * 3-> DC Chroma n = iCbCr
1172 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1173 * 5-> Luma8x8 n = 4 * luma8x8idx */
1175 /* Partially inline the CABAC residual decode: inline the coded block flag.
1176 * This has very little impact on binary size and improves performance
1177 * because it allows improved constant propagation into get_cabac_cbf_ctx,
1178 * as well as because most blocks have zero CBFs. */
1180 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1181 /* read coded block flag */
1182 if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1183 h->non_zero_count_cache[scan8[n]] = 0;
1186 decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1189 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 ) {
1190 /* read coded block flag */
1191 if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1192 h->non_zero_count_cache[scan8[n]] = 0;
1195 decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1199 * decodes a macroblock
1200 * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1202 int ff_h264_decode_mb_cabac(H264Context *h) {
1203 MpegEncContext * const s = &h->s;
1205 int mb_type, partition_count, cbp = 0;
1206 int dct8x8_allowed= h->pps.transform_8x8_mode;
1208 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1210 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1211 if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1213 /* a skipped mb needs the aff flag from the following mb */
1214 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1215 skip = h->next_mb_skipped;
1217 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1218 /* read skip flags */
1220 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1221 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1222 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1223 if(!h->next_mb_skipped)
1224 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1229 h->cbp_table[mb_xy] = 0;
1230 h->chroma_pred_mode_table[mb_xy] = 0;
1231 h->last_qscale_diff = 0;
1238 if( (s->mb_y&1) == 0 )
1240 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1243 h->prev_mb_skipped = 0;
1245 fill_decode_neighbors(h, -(MB_FIELD));
1247 if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1249 assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1251 if( !IS_DIRECT( h->left_type[0]-1 ) )
1253 if( !IS_DIRECT( h->top_type-1 ) )
1256 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1257 mb_type= 0; /* B_Direct_16x16 */
1258 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1259 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1262 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1263 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1264 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1265 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1267 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1268 }else if( bits == 13 ){
1269 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1270 goto decode_intra_mb;
1271 }else if( bits == 14 ){
1272 mb_type= 11; /* B_L1_L0_8x16 */
1273 }else if( bits == 15 ){
1274 mb_type= 22; /* B_8x8 */
1276 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1277 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1280 partition_count= b_mb_type_info[mb_type].partition_count;
1281 mb_type= b_mb_type_info[mb_type].type;
1282 } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1283 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1285 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1286 /* P_L0_D16x16, P_8x8 */
1287 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1289 /* P_L0_D8x16, P_L0_D16x8 */
1290 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1292 partition_count= p_mb_type_info[mb_type].partition_count;
1293 mb_type= p_mb_type_info[mb_type].type;
1295 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1296 goto decode_intra_mb;
1299 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1300 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1302 assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1304 partition_count = 0;
1305 cbp= i_mb_type_info[mb_type].cbp;
1306 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1307 mb_type= i_mb_type_info[mb_type].type;
1310 mb_type |= MB_TYPE_INTERLACED;
1312 h->slice_table[ mb_xy ]= h->slice_num;
1314 if(IS_INTRA_PCM(mb_type)) {
1315 const int mb_size = 384*h->sps.bit_depth_luma/8;
1318 // We assume these blocks are very rare so we do not optimize it.
1319 // FIXME The two following lines get the bitstream position in the cabac
1320 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1321 ptr= h->cabac.bytestream;
1322 if(h->cabac.low&0x1) ptr--;
1324 if(h->cabac.low&0x1FF) ptr--;
1327 // The pixels are stored in the same order as levels in h->mb array.
1328 memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1330 memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1333 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1335 // All blocks are present
1336 h->cbp_table[mb_xy] = 0x1ef;
1337 h->chroma_pred_mode_table[mb_xy] = 0;
1338 // In deblocking, the quantizer is 0
1339 s->current_picture.qscale_table[mb_xy]= 0;
1340 // All coeffs are present
1341 memset(h->non_zero_count[mb_xy], 16, 32);
1342 s->current_picture.mb_type[mb_xy]= mb_type;
1343 h->last_qscale_diff = 0;
1348 h->ref_count[0] <<= 1;
1349 h->ref_count[1] <<= 1;
1352 fill_decode_caches(h, mb_type);
1354 if( IS_INTRA( mb_type ) ) {
1356 if( IS_INTRA4x4( mb_type ) ) {
1357 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1358 mb_type |= MB_TYPE_8x8DCT;
1359 for( i = 0; i < 16; i+=4 ) {
1360 int pred = pred_intra_mode( h, i );
1361 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1362 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1365 for( i = 0; i < 16; i++ ) {
1366 int pred = pred_intra_mode( h, i );
1367 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1369 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1372 ff_h264_write_back_intra_pred_mode(h);
1373 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1375 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1376 if( h->intra16x16_pred_mode < 0 ) return -1;
1379 h->chroma_pred_mode_table[mb_xy] =
1380 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1382 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1383 if( pred_mode < 0 ) return -1;
1384 h->chroma_pred_mode= pred_mode;
1386 h->chroma_pred_mode= DC_128_PRED8x8;
1388 } else if( partition_count == 4 ) {
1389 int i, j, sub_partition_count[4], list, ref[2][4];
1391 if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1392 for( i = 0; i < 4; i++ ) {
1393 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1394 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1395 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1397 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1398 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1399 ff_h264_pred_direct_motion(h, &mb_type);
1400 h->ref_cache[0][scan8[4]] =
1401 h->ref_cache[1][scan8[4]] =
1402 h->ref_cache[0][scan8[12]] =
1403 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1404 for( i = 0; i < 4; i++ )
1405 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1408 for( i = 0; i < 4; i++ ) {
1409 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1410 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1411 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1415 for( list = 0; list < h->list_count; list++ ) {
1416 for( i = 0; i < 4; i++ ) {
1417 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1418 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1419 if( h->ref_count[list] > 1 ){
1420 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1421 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1422 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1430 h->ref_cache[list][ scan8[4*i]+1 ]=
1431 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1436 dct8x8_allowed = get_dct8x8_allowed(h);
1438 for(list=0; list<h->list_count; list++){
1440 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1441 if(IS_DIRECT(h->sub_mb_type[i])){
1442 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1446 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1447 const int sub_mb_type= h->sub_mb_type[i];
1448 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1449 for(j=0; j<sub_partition_count[i]; j++){
1452 const int index= 4*i + block_width*j;
1453 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1454 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1455 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1456 DECODE_CABAC_MB_MVD( h, list, index)
1457 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1459 if(IS_SUB_8X8(sub_mb_type)){
1461 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1463 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1466 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1468 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1469 }else if(IS_SUB_8X4(sub_mb_type)){
1470 mv_cache[ 1 ][0]= mx;
1471 mv_cache[ 1 ][1]= my;
1473 mvd_cache[ 1 ][0]= mpx;
1474 mvd_cache[ 1 ][1]= mpy;
1475 }else if(IS_SUB_4X8(sub_mb_type)){
1476 mv_cache[ 8 ][0]= mx;
1477 mv_cache[ 8 ][1]= my;
1479 mvd_cache[ 8 ][0]= mpx;
1480 mvd_cache[ 8 ][1]= mpy;
1482 mv_cache[ 0 ][0]= mx;
1483 mv_cache[ 0 ][1]= my;
1485 mvd_cache[ 0 ][0]= mpx;
1486 mvd_cache[ 0 ][1]= mpy;
1489 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1490 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1494 } else if( IS_DIRECT(mb_type) ) {
1495 ff_h264_pred_direct_motion(h, &mb_type);
1496 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1497 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1498 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1501 if(IS_16X16(mb_type)){
1502 for(list=0; list<h->list_count; list++){
1503 if(IS_DIR(mb_type, 0, list)){
1505 if(h->ref_count[list] > 1){
1506 ref= decode_cabac_mb_ref(h, list, 0);
1507 if(ref >= (unsigned)h->ref_count[list]){
1508 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1513 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1516 for(list=0; list<h->list_count; list++){
1517 if(IS_DIR(mb_type, 0, list)){
1519 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1520 DECODE_CABAC_MB_MVD( h, list, 0)
1521 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1523 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1524 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1528 else if(IS_16X8(mb_type)){
1529 for(list=0; list<h->list_count; list++){
1531 if(IS_DIR(mb_type, i, list)){
1533 if(h->ref_count[list] > 1){
1534 ref= decode_cabac_mb_ref( h, list, 8*i );
1535 if(ref >= (unsigned)h->ref_count[list]){
1536 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1541 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1543 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1546 for(list=0; list<h->list_count; list++){
1548 if(IS_DIR(mb_type, i, list)){
1550 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1551 DECODE_CABAC_MB_MVD( h, list, 8*i)
1552 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1554 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1555 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1557 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1558 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1563 assert(IS_8X16(mb_type));
1564 for(list=0; list<h->list_count; list++){
1566 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1568 if(h->ref_count[list] > 1){
1569 ref= decode_cabac_mb_ref( h, list, 4*i );
1570 if(ref >= (unsigned)h->ref_count[list]){
1571 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1576 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1578 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1581 for(list=0; list<h->list_count; list++){
1583 if(IS_DIR(mb_type, i, list)){
1585 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1586 DECODE_CABAC_MB_MVD( h, list, 4*i)
1588 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1589 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1590 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1592 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1593 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1600 if( IS_INTER( mb_type ) ) {
1601 h->chroma_pred_mode_table[mb_xy] = 0;
1602 write_back_motion( h, mb_type );
1605 if( !IS_INTRA16x16( mb_type ) ) {
1606 cbp = decode_cabac_mb_cbp_luma( h );
1608 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1611 h->cbp_table[mb_xy] = h->cbp = cbp;
1613 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1614 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1616 s->current_picture.mb_type[mb_xy]= mb_type;
1618 if( cbp || IS_INTRA16x16( mb_type ) ) {
1619 const uint8_t *scan, *scan8x8;
1620 const uint32_t *qmul;
1622 if(IS_INTERLACED(mb_type)){
1623 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1624 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1626 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1627 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1630 // decode_cabac_mb_dqp
1631 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1634 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1636 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1639 if(val > 2*max_qp){ //prevent infinite loop
1640 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1648 val= -((val + 1)>>1);
1649 h->last_qscale_diff = val;
1651 if(((unsigned)s->qscale) > max_qp){
1652 if(s->qscale<0) s->qscale+= max_qp+1;
1653 else s->qscale-= max_qp+1;
1655 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1656 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1658 h->last_qscale_diff=0;
1660 if( IS_INTRA16x16( mb_type ) ) {
1662 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1663 AV_ZERO128(h->mb_luma_dc+0);
1664 AV_ZERO128(h->mb_luma_dc+8);
1665 AV_ZERO128(h->mb_luma_dc+16);
1666 AV_ZERO128(h->mb_luma_dc+24);
1667 decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1670 qmul = h->dequant4_coeff[0][s->qscale];
1671 for( i = 0; i < 16; i++ ) {
1672 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1673 decode_cabac_residual_nondc(h, h->mb + (16*i<<h->pixel_shift), 1, i, scan + 1, qmul, 15);
1676 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1680 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1681 if( cbp & (1<<i8x8) ) {
1682 if( IS_8x8DCT(mb_type) ) {
1683 decode_cabac_residual_nondc(h, h->mb + (64*i8x8<<h->pixel_shift), 5, 4*i8x8,
1684 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1686 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1687 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1688 const int index = 4*i8x8 + i4x4;
1689 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1691 decode_cabac_residual_nondc(h, h->mb + (16*index<<h->pixel_shift), 2, index, scan, qmul, 16);
1692 //STOP_TIMER("decode_residual")
1696 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1697 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1704 for( c = 0; c < 2; c++ ) {
1705 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1706 decode_cabac_residual_dc(h, h->mb + ((256 + 16*4*c)<<h->pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1712 for( c = 0; c < 2; c++ ) {
1713 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1714 for( i = 0; i < 4; i++ ) {
1715 const int index = 16 + 4 * c + i;
1716 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1717 decode_cabac_residual_nondc(h, h->mb + (16*index<<h->pixel_shift), 4, index, scan + 1, qmul, 15);
1721 uint8_t * const nnz= &h->non_zero_count_cache[0];
1722 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1723 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1726 uint8_t * const nnz= &h->non_zero_count_cache[0];
1727 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1728 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1729 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1730 h->last_qscale_diff = 0;
1733 s->current_picture.qscale_table[mb_xy]= s->qscale;
1734 write_back_non_zero_count(h);
1737 h->ref_count[0] >>= 1;
1738 h->ref_count[1] >>= 1;