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 Libav.
7 * Libav 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 * Libav 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 Libav; 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;
1104 #define STORE_BLOCK(type) \
1106 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1108 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;
1207 const int pixel_shift = h->pixel_shift;
1209 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1211 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1212 if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1214 /* a skipped mb needs the aff flag from the following mb */
1215 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1216 skip = h->next_mb_skipped;
1218 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1219 /* read skip flags */
1221 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1222 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1223 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1224 if(!h->next_mb_skipped)
1225 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1230 h->cbp_table[mb_xy] = 0;
1231 h->chroma_pred_mode_table[mb_xy] = 0;
1232 h->last_qscale_diff = 0;
1239 if( (s->mb_y&1) == 0 )
1241 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1244 h->prev_mb_skipped = 0;
1246 fill_decode_neighbors(h, -(MB_FIELD));
1248 if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1250 assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1252 if( !IS_DIRECT( h->left_type[0]-1 ) )
1254 if( !IS_DIRECT( h->top_type-1 ) )
1257 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1258 mb_type= 0; /* B_Direct_16x16 */
1259 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1260 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1263 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1264 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1265 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1266 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1268 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1269 }else if( bits == 13 ){
1270 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1271 goto decode_intra_mb;
1272 }else if( bits == 14 ){
1273 mb_type= 11; /* B_L1_L0_8x16 */
1274 }else if( bits == 15 ){
1275 mb_type= 22; /* B_8x8 */
1277 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1278 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1281 partition_count= b_mb_type_info[mb_type].partition_count;
1282 mb_type= b_mb_type_info[mb_type].type;
1283 } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1284 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1286 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1287 /* P_L0_D16x16, P_8x8 */
1288 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1290 /* P_L0_D8x16, P_L0_D16x8 */
1291 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1293 partition_count= p_mb_type_info[mb_type].partition_count;
1294 mb_type= p_mb_type_info[mb_type].type;
1296 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1297 goto decode_intra_mb;
1300 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1301 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1303 assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1305 partition_count = 0;
1306 cbp= i_mb_type_info[mb_type].cbp;
1307 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1308 mb_type= i_mb_type_info[mb_type].type;
1311 mb_type |= MB_TYPE_INTERLACED;
1313 h->slice_table[ mb_xy ]= h->slice_num;
1315 if(IS_INTRA_PCM(mb_type)) {
1316 const int mb_size = (384*h->sps.bit_depth_luma) >> 3;
1319 // We assume these blocks are very rare so we do not optimize it.
1320 // FIXME The two following lines get the bitstream position in the cabac
1321 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1322 ptr= h->cabac.bytestream;
1323 if(h->cabac.low&0x1) ptr--;
1325 if(h->cabac.low&0x1FF) ptr--;
1328 // The pixels are stored in the same order as levels in h->mb array.
1329 memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1331 memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1334 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1336 // All blocks are present
1337 h->cbp_table[mb_xy] = 0x1ef;
1338 h->chroma_pred_mode_table[mb_xy] = 0;
1339 // In deblocking, the quantizer is 0
1340 s->current_picture.qscale_table[mb_xy]= 0;
1341 // All coeffs are present
1342 memset(h->non_zero_count[mb_xy], 16, 32);
1343 s->current_picture.mb_type[mb_xy]= mb_type;
1344 h->last_qscale_diff = 0;
1349 h->ref_count[0] <<= 1;
1350 h->ref_count[1] <<= 1;
1353 fill_decode_caches(h, mb_type);
1355 if( IS_INTRA( mb_type ) ) {
1357 if( IS_INTRA4x4( mb_type ) ) {
1358 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1359 mb_type |= MB_TYPE_8x8DCT;
1360 for( i = 0; i < 16; i+=4 ) {
1361 int pred = pred_intra_mode( h, i );
1362 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1363 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1366 for( i = 0; i < 16; i++ ) {
1367 int pred = pred_intra_mode( h, i );
1368 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1370 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1373 ff_h264_write_back_intra_pred_mode(h);
1374 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1376 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1377 if( h->intra16x16_pred_mode < 0 ) return -1;
1380 h->chroma_pred_mode_table[mb_xy] =
1381 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1383 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1384 if( pred_mode < 0 ) return -1;
1385 h->chroma_pred_mode= pred_mode;
1387 h->chroma_pred_mode= DC_128_PRED8x8;
1389 } else if( partition_count == 4 ) {
1390 int i, j, sub_partition_count[4], list, ref[2][4];
1392 if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1393 for( i = 0; i < 4; i++ ) {
1394 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1395 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1396 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1398 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1399 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1400 ff_h264_pred_direct_motion(h, &mb_type);
1401 h->ref_cache[0][scan8[4]] =
1402 h->ref_cache[1][scan8[4]] =
1403 h->ref_cache[0][scan8[12]] =
1404 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1405 for( i = 0; i < 4; i++ )
1406 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1409 for( i = 0; i < 4; i++ ) {
1410 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1411 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1412 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1416 for( list = 0; list < h->list_count; list++ ) {
1417 for( i = 0; i < 4; i++ ) {
1418 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1419 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1420 if( h->ref_count[list] > 1 ){
1421 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1422 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1423 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1431 h->ref_cache[list][ scan8[4*i]+1 ]=
1432 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1437 dct8x8_allowed = get_dct8x8_allowed(h);
1439 for(list=0; list<h->list_count; list++){
1441 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1442 if(IS_DIRECT(h->sub_mb_type[i])){
1443 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1447 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1448 const int sub_mb_type= h->sub_mb_type[i];
1449 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1450 for(j=0; j<sub_partition_count[i]; j++){
1453 const int index= 4*i + block_width*j;
1454 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1455 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1456 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1457 DECODE_CABAC_MB_MVD( h, list, index)
1458 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1460 if(IS_SUB_8X8(sub_mb_type)){
1462 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1464 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1467 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1469 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1470 }else if(IS_SUB_8X4(sub_mb_type)){
1471 mv_cache[ 1 ][0]= mx;
1472 mv_cache[ 1 ][1]= my;
1474 mvd_cache[ 1 ][0]= mpx;
1475 mvd_cache[ 1 ][1]= mpy;
1476 }else if(IS_SUB_4X8(sub_mb_type)){
1477 mv_cache[ 8 ][0]= mx;
1478 mv_cache[ 8 ][1]= my;
1480 mvd_cache[ 8 ][0]= mpx;
1481 mvd_cache[ 8 ][1]= mpy;
1483 mv_cache[ 0 ][0]= mx;
1484 mv_cache[ 0 ][1]= my;
1486 mvd_cache[ 0 ][0]= mpx;
1487 mvd_cache[ 0 ][1]= mpy;
1490 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1491 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1495 } else if( IS_DIRECT(mb_type) ) {
1496 ff_h264_pred_direct_motion(h, &mb_type);
1497 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1498 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1499 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1502 if(IS_16X16(mb_type)){
1503 for(list=0; list<h->list_count; list++){
1504 if(IS_DIR(mb_type, 0, list)){
1506 if(h->ref_count[list] > 1){
1507 ref= decode_cabac_mb_ref(h, list, 0);
1508 if(ref >= (unsigned)h->ref_count[list]){
1509 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1514 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1517 for(list=0; list<h->list_count; list++){
1518 if(IS_DIR(mb_type, 0, list)){
1520 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1521 DECODE_CABAC_MB_MVD( h, list, 0)
1522 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1524 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1525 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1529 else if(IS_16X8(mb_type)){
1530 for(list=0; list<h->list_count; list++){
1532 if(IS_DIR(mb_type, i, list)){
1534 if(h->ref_count[list] > 1){
1535 ref= decode_cabac_mb_ref( h, list, 8*i );
1536 if(ref >= (unsigned)h->ref_count[list]){
1537 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1542 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1544 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1547 for(list=0; list<h->list_count; list++){
1549 if(IS_DIR(mb_type, i, list)){
1551 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1552 DECODE_CABAC_MB_MVD( h, list, 8*i)
1553 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1555 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1556 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1558 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1559 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1564 assert(IS_8X16(mb_type));
1565 for(list=0; list<h->list_count; list++){
1567 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1569 if(h->ref_count[list] > 1){
1570 ref= decode_cabac_mb_ref( h, list, 4*i );
1571 if(ref >= (unsigned)h->ref_count[list]){
1572 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1577 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1579 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1582 for(list=0; list<h->list_count; list++){
1584 if(IS_DIR(mb_type, i, list)){
1586 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1587 DECODE_CABAC_MB_MVD( h, list, 4*i)
1589 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1590 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1591 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1593 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1594 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1601 if( IS_INTER( mb_type ) ) {
1602 h->chroma_pred_mode_table[mb_xy] = 0;
1603 write_back_motion( h, mb_type );
1606 if( !IS_INTRA16x16( mb_type ) ) {
1607 cbp = decode_cabac_mb_cbp_luma( h );
1609 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1612 h->cbp_table[mb_xy] = h->cbp = cbp;
1614 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1615 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1617 s->current_picture.mb_type[mb_xy]= mb_type;
1619 if( cbp || IS_INTRA16x16( mb_type ) ) {
1620 const uint8_t *scan, *scan8x8;
1621 const uint32_t *qmul;
1623 if(IS_INTERLACED(mb_type)){
1624 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1625 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1627 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1628 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1631 // decode_cabac_mb_dqp
1632 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1635 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1637 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1640 if(val > 2*max_qp){ //prevent infinite loop
1641 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1649 val= -((val + 1)>>1);
1650 h->last_qscale_diff = val;
1652 if(((unsigned)s->qscale) > max_qp){
1653 if(s->qscale<0) s->qscale+= max_qp+1;
1654 else s->qscale-= max_qp+1;
1656 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1657 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1659 h->last_qscale_diff=0;
1661 if( IS_INTRA16x16( mb_type ) ) {
1663 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1664 AV_ZERO128(h->mb_luma_dc+0);
1665 AV_ZERO128(h->mb_luma_dc+8);
1666 AV_ZERO128(h->mb_luma_dc+16);
1667 AV_ZERO128(h->mb_luma_dc+24);
1668 decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1671 qmul = h->dequant4_coeff[0][s->qscale];
1672 for( i = 0; i < 16; i++ ) {
1673 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1674 decode_cabac_residual_nondc(h, h->mb + (16*i << pixel_shift), 1, i, scan + 1, qmul, 15);
1677 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1681 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1682 if( cbp & (1<<i8x8) ) {
1683 if( IS_8x8DCT(mb_type) ) {
1684 decode_cabac_residual_nondc(h, h->mb + (64*i8x8 << pixel_shift), 5, 4*i8x8,
1685 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1687 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1688 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1689 const int index = 4*i8x8 + i4x4;
1690 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1692 decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 2, index, scan, qmul, 16);
1693 //STOP_TIMER("decode_residual")
1697 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1698 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1705 for( c = 0; c < 2; c++ ) {
1706 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1707 decode_cabac_residual_dc(h, h->mb + ((256 + 16*4*c) << pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1713 for( c = 0; c < 2; c++ ) {
1714 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1715 for( i = 0; i < 4; i++ ) {
1716 const int index = 16 + 4 * c + i;
1717 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1718 decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);
1722 uint8_t * const nnz= &h->non_zero_count_cache[0];
1723 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1724 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1727 uint8_t * const nnz= &h->non_zero_count_cache[0];
1728 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1729 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1730 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1731 h->last_qscale_diff = 0;
1734 s->current_picture.qscale_table[mb_xy]= s->qscale;
1735 write_back_non_zero_count(h);
1738 h->ref_count[0] >>= 1;
1739 h->ref_count[1] >>= 1;