2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * @file libavcodec/h264_cabac.c
24 * H.264 / AVC / MPEG4 part10 cabac decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
35 #include "h264_mvpred.h"
40 #include "x86/h264_i386.h"
46 /* Cabac pre state table */
48 static const int8_t cabac_context_init_I[460][2] =
51 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
52 { 2, 54 }, { 3, 74 }, { -28,127 }, { -23, 104 },
53 { -6, 53 }, { -1, 54 }, { 7, 51 },
55 /* 11 - 23 unsused for I */
56 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
57 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
58 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
62 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
63 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
64 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
65 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
68 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
69 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
70 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 },
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
80 { 13, 41 }, { 3, 62 },
83 { 0, 11 }, { 1, 55 }, { 0, 69 }, { -17, 127 },
84 { -13, 102 },{ 0, 82 }, { -7, 74 }, { -21, 107 },
85 { -27, 127 },{ -31, 127 },{ -24, 127 }, { -18, 95 },
86 { -27, 127 },{ -21, 114 },{ -30, 127 }, { -17, 123 },
87 { -12, 115 },{ -16, 122 },
90 { -11, 115 },{ -12, 63 }, { -2, 68 }, { -15, 84 },
91 { -13, 104 },{ -3, 70 }, { -8, 93 }, { -10, 90 },
92 { -30, 127 },{ -1, 74 }, { -6, 97 }, { -7, 91 },
93 { -20, 127 },{ -4, 56 }, { -5, 82 }, { -7, 76 },
97 { -7, 93 }, { -11, 87 }, { -3, 77 }, { -5, 71 },
98 { -4, 63 }, { -4, 68 }, { -12, 84 }, { -7, 62 },
99 { -7, 65 }, { 8, 61 }, { 5, 56 }, { -2, 66 },
100 { 1, 64 }, { 0, 61 }, { -2, 78 }, { 1, 50 },
101 { 7, 52 }, { 10, 35 }, { 0, 44 }, { 11, 38 },
102 { 1, 45 }, { 0, 46 }, { 5, 44 }, { 31, 17 },
103 { 1, 51 }, { 7, 50 }, { 28, 19 }, { 16, 33 },
104 { 14, 62 }, { -13, 108 },{ -15, 100 },
107 { -13, 101 },{ -13, 91 }, { -12, 94 }, { -10, 88 },
108 { -16, 84 }, { -10, 86 }, { -7, 83 }, { -13, 87 },
109 { -19, 94 }, { 1, 70 }, { 0, 72 }, { -5, 74 },
110 { 18, 59 }, { -8, 102 }, { -15, 100 }, { 0, 95 },
111 { -4, 75 }, { 2, 72 }, { -11, 75 }, { -3, 71 },
112 { 15, 46 }, { -13, 69 }, { 0, 62 }, { 0, 65 },
113 { 21, 37 }, { -15, 72 }, { 9, 57 }, { 16, 54 },
114 { 0, 62 }, { 12, 72 },
117 { 24, 0 }, { 15, 9 }, { 8, 25 }, { 13, 18 },
118 { 15, 9 }, { 13, 19 }, { 10, 37 }, { 12, 18 },
119 { 6, 29 }, { 20, 33 }, { 15, 30 }, { 4, 45 },
120 { 1, 58 }, { 0, 62 }, { 7, 61 }, { 12, 38 },
121 { 11, 45 }, { 15, 39 }, { 11, 42 }, { 13, 44 },
122 { 16, 45 }, { 12, 41 }, { 10, 49 }, { 30, 34 },
123 { 18, 42 }, { 10, 55 }, { 17, 51 }, { 17, 46 },
124 { 0, 89 }, { 26, -19 }, { 22, -17 },
127 { 26, -17 }, { 30, -25 }, { 28, -20 }, { 33, -23 },
128 { 37, -27 }, { 33, -23 }, { 40, -28 }, { 38, -17 },
129 { 33, -11 }, { 40, -15 }, { 41, -6 }, { 38, 1 },
130 { 41, 17 }, { 30, -6 }, { 27, 3 }, { 26, 22 },
131 { 37, -16 }, { 35, -4 }, { 38, -8 }, { 38, -3 },
132 { 37, 3 }, { 38, 5 }, { 42, 0 }, { 35, 16 },
133 { 39, 22 }, { 14, 48 }, { 27, 37 }, { 21, 60 },
134 { 12, 68 }, { 2, 97 },
137 { -3, 71 }, { -6, 42 }, { -5, 50 }, { -3, 54 },
138 { -2, 62 }, { 0, 58 }, { 1, 63 }, { -2, 72 },
139 { -1, 74 }, { -9, 91 }, { -5, 67 }, { -5, 27 },
140 { -3, 39 }, { -2, 44 }, { 0, 46 }, { -16, 64 },
141 { -8, 68 }, { -10, 78 }, { -6, 77 }, { -10, 86 },
142 { -12, 92 }, { -15, 55 }, { -10, 60 }, { -6, 62 },
146 { -12, 73 }, { -8, 76 }, { -7, 80 }, { -9, 88 },
147 { -17, 110 },{ -11, 97 }, { -20, 84 }, { -11, 79 },
148 { -6, 73 }, { -4, 74 }, { -13, 86 }, { -13, 96 },
149 { -11, 97 }, { -19, 117 },{ -8, 78 }, { -5, 33 },
150 { -4, 48 }, { -2, 53 }, { -3, 62 }, { -13, 71 },
151 { -10, 79 }, { -12, 86 }, { -13, 90 }, { -14, 97 },
153 /* 276 a bit special (not used, bypass is used instead) */
157 { -6, 93 }, { -6, 84 }, { -8, 79 }, { 0, 66 },
158 { -1, 71 }, { 0, 62 }, { -2, 60 }, { -2, 59 },
159 { -5, 75 }, { -3, 62 }, { -4, 58 }, { -9, 66 },
160 { -1, 79 }, { 0, 71 }, { 3, 68 }, { 10, 44 },
161 { -7, 62 }, { 15, 36 }, { 14, 40 }, { 16, 27 },
162 { 12, 29 }, { 1, 44 }, { 20, 36 }, { 18, 32 },
163 { 5, 42 }, { 1, 48 }, { 10, 62 }, { 17, 46 },
164 { 9, 64 }, { -12, 104 },{ -11, 97 },
167 { -16, 96 }, { -7, 88 }, { -8, 85 }, { -7, 85 },
168 { -9, 85 }, { -13, 88 }, { 4, 66 }, { -3, 77 },
169 { -3, 76 }, { -6, 76 }, { 10, 58 }, { -1, 76 },
170 { -1, 83 }, { -7, 99 }, { -14, 95 }, { 2, 95 },
171 { 0, 76 }, { -5, 74 }, { 0, 70 }, { -11, 75 },
172 { 1, 68 }, { 0, 65 }, { -14, 73 }, { 3, 62 },
173 { 4, 62 }, { -1, 68 }, { -13, 75 }, { 11, 55 },
174 { 5, 64 }, { 12, 70 },
177 { 15, 6 }, { 6, 19 }, { 7, 16 }, { 12, 14 },
178 { 18, 13 }, { 13, 11 }, { 13, 15 }, { 15, 16 },
179 { 12, 23 }, { 13, 23 }, { 15, 20 }, { 14, 26 },
180 { 14, 44 }, { 17, 40 }, { 17, 47 }, { 24, 17 },
181 { 21, 21 }, { 25, 22 }, { 31, 27 }, { 22, 29 },
182 { 19, 35 }, { 14, 50 }, { 10, 57 }, { 7, 63 },
183 { -2, 77 }, { -4, 82 }, { -3, 94 }, { 9, 69 },
184 { -12, 109 },{ 36, -35 }, { 36, -34 },
187 { 32, -26 }, { 37, -30 }, { 44, -32 }, { 34, -18 },
188 { 34, -15 }, { 40, -15 }, { 33, -7 }, { 35, -5 },
189 { 33, 0 }, { 38, 2 }, { 33, 13 }, { 23, 35 },
190 { 13, 58 }, { 29, -3 }, { 26, 0 }, { 22, 30 },
191 { 31, -7 }, { 35, -15 }, { 34, -3 }, { 34, 3 },
192 { 36, -1 }, { 34, 5 }, { 32, 11 }, { 35, 5 },
193 { 34, 12 }, { 39, 11 }, { 30, 29 }, { 34, 26 },
194 { 29, 39 }, { 19, 66 },
197 { 31, 21 }, { 31, 31 }, { 25, 50 },
198 { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11, 85 },
199 { -15, 92 }, { -14, 89 }, { -26, 71 }, { -15, 81 },
200 { -14, 80 }, { 0, 68 }, { -14, 70 }, { -24, 56 },
201 { -23, 68 }, { -24, 50 }, { -11, 74 }, { 23, -13 },
202 { 26, -13 }, { 40, -15 }, { 49, -14 }, { 44, 3 },
203 { 45, 6 }, { 44, 34 }, { 33, 54 }, { 19, 82 },
204 { -3, 75 }, { -1, 23 }, { 1, 34 }, { 1, 43 },
205 { 0, 54 }, { -2, 55 }, { 0, 61 }, { 1, 64 },
206 { 0, 68 }, { -9, 92 },
209 { -14, 106 }, { -13, 97 }, { -15, 90 }, { -12, 90 },
210 { -18, 88 }, { -10, 73 }, { -9, 79 }, { -14, 86 },
211 { -10, 73 }, { -10, 70 }, { -10, 69 }, { -5, 66 },
212 { -9, 64 }, { -5, 58 }, { 2, 59 }, { 21, -10 },
213 { 24, -11 }, { 28, -8 }, { 28, -1 }, { 29, 3 },
214 { 29, 9 }, { 35, 20 }, { 29, 36 }, { 14, 67 }
217 static const int8_t cabac_context_init_PB[3][460][2] =
219 /* i_cabac_init_idc == 0 */
222 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
223 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
224 { -6, 53 }, { -1, 54 }, { 7, 51 },
227 { 23, 33 }, { 23, 2 }, { 21, 0 }, { 1, 9 },
228 { 0, 49 }, { -37, 118 }, { 5, 57 }, { -13, 78 },
229 { -11, 65 }, { 1, 62 }, { 12, 49 }, { -4, 73 },
233 { 18, 64 }, { 9, 43 }, { 29, 0 }, { 26, 67 },
234 { 16, 90 }, { 9, 104 }, { -46, 127 }, { -20, 104 },
235 { 1, 67 }, { -13, 78 }, { -11, 65 }, { 1, 62 },
236 { -6, 86 }, { -17, 95 }, { -6, 61 }, { 9, 45 },
239 { -3, 69 }, { -6, 81 }, { -11, 96 }, { 6, 55 },
240 { 7, 67 }, { -5, 86 }, { 2, 88 }, { 0, 58 },
241 { -3, 76 }, { -10, 94 }, { 5, 54 }, { 4, 69 },
242 { -3, 81 }, { 0, 88 },
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 },
246 { -7, 72 }, { 1, 58 },
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
251 { 13, 41 }, { 3, 62 },
254 { 0, 45 }, { -4, 78 }, { -3, 96 }, { -27, 126 },
255 { -28, 98 }, { -25, 101 }, { -23, 67 }, { -28, 82 },
256 { -20, 94 }, { -16, 83 }, { -22, 110 }, { -21, 91 },
257 { -18, 102 }, { -13, 93 }, { -29, 127 }, { -7, 92 },
258 { -5, 89 }, { -7, 96 }, { -13, 108 }, { -3, 46 },
259 { -1, 65 }, { -1, 57 }, { -9, 93 }, { -3, 74 },
260 { -9, 92 }, { -8, 87 }, { -23, 126 }, { 5, 54 },
261 { 6, 60 }, { 6, 59 }, { 6, 69 }, { -1, 48 },
262 { 0, 68 }, { -4, 69 }, { -8, 88 },
265 { -2, 85 }, { -6, 78 }, { -1, 75 }, { -7, 77 },
266 { 2, 54 }, { 5, 50 }, { -3, 68 }, { 1, 50 },
267 { 6, 42 }, { -4, 81 }, { 1, 63 }, { -4, 70 },
268 { 0, 67 }, { 2, 57 }, { -2, 76 }, { 11, 35 },
269 { 4, 64 }, { 1, 61 }, { 11, 35 }, { 18, 25 },
270 { 12, 24 }, { 13, 29 }, { 13, 36 }, { -10, 93 },
271 { -7, 73 }, { -2, 73 }, { 13, 46 }, { 9, 49 },
272 { -7, 100 }, { 9, 53 }, { 2, 53 }, { 5, 53 },
273 { -2, 61 }, { 0, 56 }, { 0, 56 }, { -13, 63 },
274 { -5, 60 }, { -1, 62 }, { 4, 57 }, { -6, 69 },
275 { 4, 57 }, { 14, 39 }, { 4, 51 }, { 13, 68 },
276 { 3, 64 }, { 1, 61 }, { 9, 63 }, { 7, 50 },
277 { 16, 39 }, { 5, 44 }, { 4, 52 }, { 11, 48 },
278 { -5, 60 }, { -1, 59 }, { 0, 59 }, { 22, 33 },
279 { 5, 44 }, { 14, 43 }, { -1, 78 }, { 0, 60 },
283 { 11, 28 }, { 2, 40 }, { 3, 44 }, { 0, 49 },
284 { 0, 46 }, { 2, 44 }, { 2, 51 }, { 0, 47 },
285 { 4, 39 }, { 2, 62 }, { 6, 46 }, { 0, 54 },
286 { 3, 54 }, { 2, 58 }, { 4, 63 }, { 6, 51 },
287 { 6, 57 }, { 7, 53 }, { 6, 52 }, { 6, 55 },
288 { 11, 45 }, { 14, 36 }, { 8, 53 }, { -1, 82 },
289 { 7, 55 }, { -3, 78 }, { 15, 46 }, { 22, 31 },
290 { -1, 84 }, { 25, 7 }, { 30, -7 }, { 28, 3 },
291 { 28, 4 }, { 32, 0 }, { 34, -1 }, { 30, 6 },
292 { 30, 6 }, { 32, 9 }, { 31, 19 }, { 26, 27 },
293 { 26, 30 }, { 37, 20 }, { 28, 34 }, { 17, 70 },
294 { 1, 67 }, { 5, 59 }, { 9, 67 }, { 16, 30 },
295 { 18, 32 }, { 18, 35 }, { 22, 29 }, { 24, 31 },
296 { 23, 38 }, { 18, 43 }, { 20, 41 }, { 11, 63 },
297 { 9, 59 }, { 9, 64 }, { -1, 94 }, { -2, 89 },
301 { -6, 76 }, { -2, 44 }, { 0, 45 }, { 0, 52 },
302 { -3, 64 }, { -2, 59 }, { -4, 70 }, { -4, 75 },
303 { -8, 82 }, { -17, 102 }, { -9, 77 }, { 3, 24 },
304 { 0, 42 }, { 0, 48 }, { 0, 55 }, { -6, 59 },
305 { -7, 71 }, { -12, 83 }, { -11, 87 }, { -30, 119 },
306 { 1, 58 }, { -3, 29 }, { -1, 36 }, { 1, 38 },
307 { 2, 43 }, { -6, 55 }, { 0, 58 }, { 0, 64 },
308 { -3, 74 }, { -10, 90 }, { 0, 70 }, { -4, 29 },
309 { 5, 31 }, { 7, 42 }, { 1, 59 }, { -2, 58 },
310 { -3, 72 }, { -3, 81 }, { -11, 97 }, { 0, 58 },
311 { 8, 5 }, { 10, 14 }, { 14, 18 }, { 13, 27 },
312 { 2, 40 }, { 0, 58 }, { -3, 70 }, { -6, 79 },
315 /* 276 a bit special (not used, bypass is used instead) */
319 { -13, 106 }, { -16, 106 }, { -10, 87 }, { -21, 114 },
320 { -18, 110 }, { -14, 98 }, { -22, 110 }, { -21, 106 },
321 { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
322 { -10, 96 }, { -12, 95 }, { -5, 91 }, { -9, 93 },
323 { -22, 94 }, { -5, 86 }, { 9, 67 }, { -4, 80 },
324 { -10, 85 }, { -1, 70 }, { 7, 60 }, { 9, 58 },
325 { 5, 61 }, { 12, 50 }, { 15, 50 }, { 18, 49 },
326 { 17, 54 }, { 10, 41 }, { 7, 46 }, { -1, 51 },
327 { 7, 49 }, { 8, 52 }, { 9, 41 }, { 6, 47 },
328 { 2, 55 }, { 13, 41 }, { 10, 44 }, { 6, 50 },
329 { 5, 53 }, { 13, 49 }, { 4, 63 }, { 6, 64 },
330 { -2, 69 }, { -2, 59 }, { 6, 70 }, { 10, 44 },
331 { 9, 31 }, { 12, 43 }, { 3, 53 }, { 14, 34 },
332 { 10, 38 }, { -3, 52 }, { 13, 40 }, { 17, 32 },
333 { 7, 44 }, { 7, 38 }, { 13, 50 }, { 10, 57 },
337 { 14, 11 }, { 11, 14 }, { 9, 11 }, { 18, 11 },
338 { 21, 9 }, { 23, -2 }, { 32, -15 }, { 32, -15 },
339 { 34, -21 }, { 39, -23 }, { 42, -33 }, { 41, -31 },
340 { 46, -28 }, { 38, -12 }, { 21, 29 }, { 45, -24 },
341 { 53, -45 }, { 48, -26 }, { 65, -43 }, { 43, -19 },
342 { 39, -10 }, { 30, 9 }, { 18, 26 }, { 20, 27 },
343 { 0, 57 }, { -14, 82 }, { -5, 75 }, { -19, 97 },
344 { -35, 125 }, { 27, 0 }, { 28, 0 }, { 31, -4 },
345 { 27, 6 }, { 34, 8 }, { 30, 10 }, { 24, 22 },
346 { 33, 19 }, { 22, 32 }, { 26, 31 }, { 21, 41 },
347 { 26, 44 }, { 23, 47 }, { 16, 65 }, { 14, 71 },
348 { 8, 60 }, { 6, 63 }, { 17, 65 }, { 21, 24 },
349 { 23, 20 }, { 26, 23 }, { 27, 32 }, { 28, 23 },
350 { 28, 24 }, { 23, 40 }, { 24, 32 }, { 28, 29 },
351 { 23, 42 }, { 19, 57 }, { 22, 53 }, { 22, 61 },
355 { 12, 40 }, { 11, 51 }, { 14, 59 },
356 { -4, 79 }, { -7, 71 }, { -5, 69 }, { -9, 70 },
357 { -8, 66 }, { -10, 68 }, { -19, 73 }, { -12, 69 },
358 { -16, 70 }, { -15, 67 }, { -20, 62 }, { -19, 70 },
359 { -16, 66 }, { -22, 65 }, { -20, 63 }, { 9, -2 },
360 { 26, -9 }, { 33, -9 }, { 39, -7 }, { 41, -2 },
361 { 45, 3 }, { 49, 9 }, { 45, 27 }, { 36, 59 },
362 { -6, 66 }, { -7, 35 }, { -7, 42 }, { -8, 45 },
363 { -5, 48 }, { -12, 56 }, { -6, 60 }, { -5, 62 },
364 { -8, 66 }, { -8, 76 },
367 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
368 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
369 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
370 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 21, -13 },
371 { 33, -14 }, { 39, -7 }, { 46, -2 }, { 51, 2 },
372 { 60, 6 }, { 61, 17 }, { 55, 34 }, { 42, 62 },
375 /* i_cabac_init_idc == 1 */
378 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
379 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
380 { -6, 53 }, { -1, 54 }, { 7, 51 },
383 { 22, 25 }, { 34, 0 }, { 16, 0 }, { -2, 9 },
384 { 4, 41 }, { -29, 118 }, { 2, 65 }, { -6, 71 },
385 { -13, 79 }, { 5, 52 }, { 9, 50 }, { -3, 70 },
389 { 26, 34 }, { 19, 22 }, { 40, 0 }, { 57, 2 },
390 { 41, 36 }, { 26, 69 }, { -45, 127 }, { -15, 101 },
391 { -4, 76 }, { -6, 71 }, { -13, 79 }, { 5, 52 },
392 { 6, 69 }, { -13, 90 }, { 0, 52 }, { 8, 43 },
395 { -2, 69 },{ -5, 82 },{ -10, 96 },{ 2, 59 },
396 { 2, 75 },{ -3, 87 },{ -3, 100 },{ 1, 56 },
397 { -3, 74 },{ -6, 85 },{ 0, 59 },{ -3, 81 },
398 { -7, 86 },{ -5, 95 },
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 },
402 { -5, 72 },{ 0, 61 },
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
407 { 13, 41 }, { 3, 62 },
410 { 13, 15 }, { 7, 51 }, { 2, 80 }, { -39, 127 },
411 { -18, 91 }, { -17, 96 }, { -26, 81 }, { -35, 98 },
412 { -24, 102 }, { -23, 97 }, { -27, 119 }, { -24, 99 },
413 { -21, 110 }, { -18, 102 }, { -36, 127 }, { 0, 80 },
414 { -5, 89 }, { -7, 94 }, { -4, 92 }, { 0, 39 },
415 { 0, 65 }, { -15, 84 }, { -35, 127 }, { -2, 73 },
416 { -12, 104 }, { -9, 91 }, { -31, 127 }, { 3, 55 },
417 { 7, 56 }, { 7, 55 }, { 8, 61 }, { -3, 53 },
418 { 0, 68 }, { -7, 74 }, { -9, 88 },
421 { -13, 103 }, { -13, 91 }, { -9, 89 }, { -14, 92 },
422 { -8, 76 }, { -12, 87 }, { -23, 110 }, { -24, 105 },
423 { -10, 78 }, { -20, 112 }, { -17, 99 }, { -78, 127 },
424 { -70, 127 }, { -50, 127 }, { -46, 127 }, { -4, 66 },
425 { -5, 78 }, { -4, 71 }, { -8, 72 }, { 2, 59 },
426 { -1, 55 }, { -7, 70 }, { -6, 75 }, { -8, 89 },
427 { -34, 119 }, { -3, 75 }, { 32, 20 }, { 30, 22 },
428 { -44, 127 }, { 0, 54 }, { -5, 61 }, { 0, 58 },
429 { -1, 60 }, { -3, 61 }, { -8, 67 }, { -25, 84 },
430 { -14, 74 }, { -5, 65 }, { 5, 52 }, { 2, 57 },
431 { 0, 61 }, { -9, 69 }, { -11, 70 }, { 18, 55 },
432 { -4, 71 }, { 0, 58 }, { 7, 61 }, { 9, 41 },
433 { 18, 25 }, { 9, 32 }, { 5, 43 }, { 9, 47 },
434 { 0, 44 }, { 0, 51 }, { 2, 46 }, { 19, 38 },
435 { -4, 66 }, { 15, 38 }, { 12, 42 }, { 9, 34 },
439 { 4, 45 }, { 10, 28 }, { 10, 31 }, { 33, -11 },
440 { 52, -43 }, { 18, 15 }, { 28, 0 }, { 35, -22 },
441 { 38, -25 }, { 34, 0 }, { 39, -18 }, { 32, -12 },
442 { 102, -94 }, { 0, 0 }, { 56, -15 }, { 33, -4 },
443 { 29, 10 }, { 37, -5 }, { 51, -29 }, { 39, -9 },
444 { 52, -34 }, { 69, -58 }, { 67, -63 }, { 44, -5 },
445 { 32, 7 }, { 55, -29 }, { 32, 1 }, { 0, 0 },
446 { 27, 36 }, { 33, -25 }, { 34, -30 }, { 36, -28 },
447 { 38, -28 }, { 38, -27 }, { 34, -18 }, { 35, -16 },
448 { 34, -14 }, { 32, -8 }, { 37, -6 }, { 35, 0 },
449 { 30, 10 }, { 28, 18 }, { 26, 25 }, { 29, 41 },
450 { 0, 75 }, { 2, 72 }, { 8, 77 }, { 14, 35 },
451 { 18, 31 }, { 17, 35 }, { 21, 30 }, { 17, 45 },
452 { 20, 42 }, { 18, 45 }, { 27, 26 }, { 16, 54 },
453 { 7, 66 }, { 16, 56 }, { 11, 73 }, { 10, 67 },
457 { -23, 112 }, { -15, 71 }, { -7, 61 }, { 0, 53 },
458 { -5, 66 }, { -11, 77 }, { -9, 80 }, { -9, 84 },
459 { -10, 87 }, { -34, 127 }, { -21, 101 }, { -3, 39 },
460 { -5, 53 }, { -7, 61 }, { -11, 75 }, { -15, 77 },
461 { -17, 91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
462 { -11, 76 }, { -10, 44 }, { -10, 52 }, { -10, 57 },
463 { -9, 58 }, { -16, 72 }, { -7, 69 }, { -4, 69 },
464 { -5, 74 }, { -9, 86 }, { 2, 66 }, { -9, 34 },
465 { 1, 32 }, { 11, 31 }, { 5, 52 }, { -2, 55 },
466 { -2, 67 }, { 0, 73 }, { -8, 89 }, { 3, 52 },
467 { 7, 4 }, { 10, 8 }, { 17, 8 }, { 16, 19 },
468 { 3, 37 }, { -1, 61 }, { -5, 73 }, { -1, 70 },
471 /* 276 a bit special (not used, bypass is used instead) */
475 { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
476 { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
477 { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
478 { -10, 95 }, { -14, 100 }, { -8, 95 }, { -17, 111 },
479 { -28, 114 }, { -6, 89 }, { -2, 80 }, { -4, 82 },
480 { -9, 85 }, { -8, 81 }, { -1, 72 }, { 5, 64 },
481 { 1, 67 }, { 9, 56 }, { 0, 69 }, { 1, 69 },
482 { 7, 69 }, { -7, 69 }, { -6, 67 }, { -16, 77 },
483 { -2, 64 }, { 2, 61 }, { -6, 67 }, { -3, 64 },
484 { 2, 57 }, { -3, 65 }, { -3, 66 }, { 0, 62 },
485 { 9, 51 }, { -1, 66 }, { -2, 71 }, { -2, 75 },
486 { -1, 70 }, { -9, 72 }, { 14, 60 }, { 16, 37 },
487 { 0, 47 }, { 18, 35 }, { 11, 37 }, { 12, 41 },
488 { 10, 41 }, { 2, 48 }, { 12, 41 }, { 13, 41 },
489 { 0, 59 }, { 3, 50 }, { 19, 40 }, { 3, 66 },
493 { 19, -6 }, { 18, -6 }, { 14, 0 }, { 26, -12 },
494 { 31, -16 }, { 33, -25 }, { 33, -22 }, { 37, -28 },
495 { 39, -30 }, { 42, -30 }, { 47, -42 }, { 45, -36 },
496 { 49, -34 }, { 41, -17 }, { 32, 9 }, { 69, -71 },
497 { 63, -63 }, { 66, -64 }, { 77, -74 }, { 54, -39 },
498 { 52, -35 }, { 41, -10 }, { 36, 0 }, { 40, -1 },
499 { 30, 14 }, { 28, 26 }, { 23, 37 }, { 12, 55 },
500 { 11, 65 }, { 37, -33 }, { 39, -36 }, { 40, -37 },
501 { 38, -30 }, { 46, -33 }, { 42, -30 }, { 40, -24 },
502 { 49, -29 }, { 38, -12 }, { 40, -10 }, { 38, -3 },
503 { 46, -5 }, { 31, 20 }, { 29, 30 }, { 25, 44 },
504 { 12, 48 }, { 11, 49 }, { 26, 45 }, { 22, 22 },
505 { 23, 22 }, { 27, 21 }, { 33, 20 }, { 26, 28 },
506 { 30, 24 }, { 27, 34 }, { 18, 42 }, { 25, 39 },
507 { 18, 50 }, { 12, 70 }, { 21, 54 }, { 14, 71 },
511 { 25, 32 }, { 21, 49 }, { 21, 54 },
512 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 },
513 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 },
514 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 },
515 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 17, -10 },
516 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
517 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
518 { -5, 71 }, { 0, 24 }, { -1, 36 }, { -2, 42 },
519 { -2, 52 }, { -9, 57 }, { -6, 63 }, { -4, 65 },
520 { -4, 67 }, { -7, 82 },
523 { -3, 81 }, { -3, 76 }, { -7, 72 }, { -6, 78 },
524 { -12, 72 }, { -14, 68 }, { -3, 70 }, { -6, 76 },
525 { -5, 66 }, { -5, 62 }, { 0, 57 }, { -4, 61 },
526 { -9, 60 }, { 1, 54 }, { 2, 58 }, { 17, -10 },
527 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 },
528 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 },
531 /* i_cabac_init_idc == 2 */
534 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 },
535 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 },
536 { -6, 53 }, { -1, 54 }, { 7, 51 },
539 { 29, 16 }, { 25, 0 }, { 14, 0 }, { -10, 51 },
540 { -3, 62 }, { -27, 99 }, { 26, 16 }, { -4, 85 },
541 { -24, 102 }, { 5, 57 }, { 6, 57 }, { -17, 73 },
545 { 20, 40 }, { 20, 10 }, { 29, 0 }, { 54, 0 },
546 { 37, 42 }, { 12, 97 }, { -32, 127 }, { -22, 117 },
547 { -2, 74 }, { -4, 85 }, { -24, 102 }, { 5, 57 },
548 { -6, 93 }, { -14, 88 }, { -6, 44 }, { 4, 55 },
551 { -11, 89 },{ -15, 103 },{ -21, 116 },{ 19, 57 },
552 { 20, 58 },{ 4, 84 },{ 6, 96 },{ 1, 63 },
553 { -5, 85 },{ -13, 106 },{ 5, 63 },{ 6, 75 },
554 { -3, 90 },{ -1, 101 },
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 },
558 { -7, 50 },{ 1, 60 },
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 },
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 },
563 { 13, 41 }, { 3, 62 },
566 { 7, 34 }, { -9, 88 }, { -20, 127 }, { -36, 127 },
567 { -17, 91 }, { -14, 95 }, { -25, 84 }, { -25, 86 },
568 { -12, 89 }, { -17, 91 }, { -31, 127 }, { -14, 76 },
569 { -18, 103 }, { -13, 90 }, { -37, 127 }, { 11, 80 },
570 { 5, 76 }, { 2, 84 }, { 5, 78 }, { -6, 55 },
571 { 4, 61 }, { -14, 83 }, { -37, 127 }, { -5, 79 },
572 { -11, 104 }, { -11, 91 }, { -30, 127 }, { 0, 65 },
573 { -2, 79 }, { 0, 72 }, { -4, 92 }, { -6, 56 },
574 { 3, 68 }, { -8, 71 }, { -13, 98 },
577 { -4, 86 }, { -12, 88 }, { -5, 82 }, { -3, 72 },
578 { -4, 67 }, { -8, 72 }, { -16, 89 }, { -9, 69 },
579 { -1, 59 }, { 5, 66 }, { 4, 57 }, { -4, 71 },
580 { -2, 71 }, { 2, 58 }, { -1, 74 }, { -4, 44 },
581 { -1, 69 }, { 0, 62 }, { -7, 51 }, { -4, 47 },
582 { -6, 42 }, { -3, 41 }, { -6, 53 }, { 8, 76 },
583 { -9, 78 }, { -11, 83 }, { 9, 52 }, { 0, 67 },
584 { -5, 90 }, { 1, 67 }, { -15, 72 }, { -5, 75 },
585 { -8, 80 }, { -21, 83 }, { -21, 64 }, { -13, 31 },
586 { -25, 64 }, { -29, 94 }, { 9, 75 }, { 17, 63 },
587 { -8, 74 }, { -5, 35 }, { -2, 27 }, { 13, 91 },
588 { 3, 65 }, { -7, 69 }, { 8, 77 }, { -10, 66 },
589 { 3, 62 }, { -3, 68 }, { -20, 81 }, { 0, 30 },
590 { 1, 7 }, { -3, 23 }, { -21, 74 }, { 16, 66 },
591 { -23, 124 }, { 17, 37 }, { 44, -18 }, { 50, -34 },
595 { 4, 39 }, { 0, 42 }, { 7, 34 }, { 11, 29 },
596 { 8, 31 }, { 6, 37 }, { 7, 42 }, { 3, 40 },
597 { 8, 33 }, { 13, 43 }, { 13, 36 }, { 4, 47 },
598 { 3, 55 }, { 2, 58 }, { 6, 60 }, { 8, 44 },
599 { 11, 44 }, { 14, 42 }, { 7, 48 }, { 4, 56 },
600 { 4, 52 }, { 13, 37 }, { 9, 49 }, { 19, 58 },
601 { 10, 48 }, { 12, 45 }, { 0, 69 }, { 20, 33 },
602 { 8, 63 }, { 35, -18 }, { 33, -25 }, { 28, -3 },
603 { 24, 10 }, { 27, 0 }, { 34, -14 }, { 52, -44 },
604 { 39, -24 }, { 19, 17 }, { 31, 25 }, { 36, 29 },
605 { 24, 33 }, { 34, 15 }, { 30, 20 }, { 22, 73 },
606 { 20, 34 }, { 19, 31 }, { 27, 44 }, { 19, 16 },
607 { 15, 36 }, { 15, 36 }, { 21, 28 }, { 25, 21 },
608 { 30, 20 }, { 31, 12 }, { 27, 16 }, { 24, 42 },
609 { 0, 93 }, { 14, 56 }, { 15, 57 }, { 26, 38 },
613 { -24, 115 }, { -22, 82 }, { -9, 62 }, { 0, 53 },
614 { 0, 59 }, { -14, 85 }, { -13, 89 }, { -13, 94 },
615 { -11, 92 }, { -29, 127 }, { -21, 100 }, { -14, 57 },
616 { -12, 67 }, { -11, 71 }, { -10, 77 }, { -21, 85 },
617 { -16, 88 }, { -23, 104 }, { -15, 98 }, { -37, 127 },
618 { -10, 82 }, { -8, 48 }, { -8, 61 }, { -8, 66 },
619 { -7, 70 }, { -14, 75 }, { -10, 79 }, { -9, 83 },
620 { -12, 92 }, { -18, 108 }, { -4, 79 }, { -22, 69 },
621 { -16, 75 }, { -2, 58 }, { 1, 58 }, { -13, 78 },
622 { -9, 83 }, { -4, 81 }, { -13, 99 }, { -13, 81 },
623 { -6, 38 }, { -13, 62 }, { -6, 58 }, { -2, 59 },
624 { -16, 73 }, { -10, 76 }, { -13, 86 }, { -9, 83 },
627 /* 276 a bit special (not used, bypass is used instead) */
631 { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
632 { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
633 { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
634 { -10, 94 }, { -15, 102 }, { -10, 99 }, { -13, 106 },
635 { -50, 127 }, { -5, 92 }, { 17, 57 }, { -5, 86 },
636 { -13, 94 }, { -12, 91 }, { -2, 77 }, { 0, 71 },
637 { -1, 73 }, { 4, 64 }, { -7, 81 }, { 5, 64 },
638 { 15, 57 }, { 1, 67 }, { 0, 68 }, { -10, 67 },
639 { 1, 68 }, { 0, 77 }, { 2, 64 }, { 0, 68 },
640 { -5, 78 }, { 7, 55 }, { 5, 59 }, { 2, 65 },
641 { 14, 54 }, { 15, 44 }, { 5, 60 }, { 2, 70 },
642 { -2, 76 }, { -18, 86 }, { 12, 70 }, { 5, 64 },
643 { -12, 70 }, { 11, 55 }, { 5, 56 }, { 0, 69 },
644 { 2, 65 }, { -6, 74 }, { 5, 54 }, { 7, 54 },
645 { -6, 76 }, { -11, 82 }, { -2, 77 }, { -2, 77 },
649 { 17, -13 }, { 16, -9 }, { 17, -12 }, { 27, -21 },
650 { 37, -30 }, { 41, -40 }, { 42, -41 }, { 48, -47 },
651 { 39, -32 }, { 46, -40 }, { 52, -51 }, { 46, -41 },
652 { 52, -39 }, { 43, -19 }, { 32, 11 }, { 61, -55 },
653 { 56, -46 }, { 62, -50 }, { 81, -67 }, { 45, -20 },
654 { 35, -2 }, { 28, 15 }, { 34, 1 }, { 39, 1 },
655 { 30, 17 }, { 20, 38 }, { 18, 45 }, { 15, 54 },
656 { 0, 79 }, { 36, -16 }, { 37, -14 }, { 37, -17 },
657 { 32, 1 }, { 34, 15 }, { 29, 15 }, { 24, 25 },
658 { 34, 22 }, { 31, 16 }, { 35, 18 }, { 31, 28 },
659 { 33, 41 }, { 36, 28 }, { 27, 47 }, { 21, 62 },
660 { 18, 31 }, { 19, 26 }, { 36, 24 }, { 24, 23 },
661 { 27, 16 }, { 24, 30 }, { 31, 29 }, { 22, 41 },
662 { 22, 42 }, { 16, 60 }, { 15, 52 }, { 14, 60 },
663 { 3, 78 }, { -16, 123 }, { 21, 53 }, { 22, 56 },
667 { 21, 33 }, { 19, 50 }, { 17, 61 },
668 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
669 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
670 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
671 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
672 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
673 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
674 { -9, 71 }, { -7, 37 }, { -8, 44 }, { -11, 49 },
675 { -10, 56 }, { -12, 59 }, { -8, 63 }, { -9, 67 },
676 { -6, 68 }, { -10, 79 },
679 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 },
680 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 },
681 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 },
682 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 },
683 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 },
684 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 },
688 void ff_h264_init_cabac_states(H264Context *h) {
689 MpegEncContext * const s = &h->s;
692 /* calculate pre-state */
693 for( i= 0; i < 460; i++ ) {
695 if( h->slice_type_nos == FF_I_TYPE )
696 pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
698 pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
701 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
703 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
707 static int decode_cabac_field_decoding_flag(H264Context *h) {
708 MpegEncContext * const s = &h->s;
709 const long mba_xy = h->mb_xy - 1L;
710 const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
712 unsigned long ctx = 0;
714 ctx += (s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
715 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
721 uint8_t *state= &h->cabac_state[ctx_base];
725 MpegEncContext * const s = &h->s;
726 const int mba_xy = h->left_mb_xy[0];
727 const int mbb_xy = h->top_mb_xy;
729 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
731 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
733 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
737 if( get_cabac_noinline( &h->cabac, state ) == 0 )
741 if( get_cabac_terminate( &h->cabac ) )
744 mb_type = 1; /* I16x16 */
745 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
746 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
747 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
748 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
749 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
753 static int decode_cabac_mb_type_b( H264Context *h ) {
754 MpegEncContext * const s = &h->s;
756 const int mba_xy = h->left_mb_xy[0];
757 const int mbb_xy = h->top_mb_xy;
760 assert(h->slice_type_nos == FF_B_TYPE);
762 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
764 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
767 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
768 return 0; /* B_Direct_16x16 */
770 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
771 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
774 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
775 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
776 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
777 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
779 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
780 else if( bits == 13 ) {
781 return decode_cabac_intra_mb_type(h, 32, 0) + 23;
782 } else if( bits == 14 )
783 return 11; /* B_L1_L0_8x16 */
784 else if( bits == 15 )
785 return 22; /* B_8x8 */
787 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
788 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
791 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
792 MpegEncContext * const s = &h->s;
796 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
797 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
800 && h->slice_table[mba_xy] == h->slice_num
801 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
802 mba_xy += s->mb_stride;
804 mbb_xy = mb_xy - s->mb_stride;
806 && h->slice_table[mbb_xy] == h->slice_num
807 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
808 mbb_xy -= s->mb_stride;
810 mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
812 int mb_xy = h->mb_xy;
814 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
817 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
819 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
822 if( h->slice_type_nos == FF_B_TYPE )
824 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
827 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
830 if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
833 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
834 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
835 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
837 if( mode >= pred_mode )
843 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
844 const int mba_xy = h->left_mb_xy[0];
845 const int mbb_xy = h->top_mb_xy;
849 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
850 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
853 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
856 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
859 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
861 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
867 static int decode_cabac_mb_cbp_luma( H264Context *h) {
868 int cbp_b, cbp_a, ctx, cbp = 0;
870 cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1;
871 cbp_b = h->slice_table[h->top_mb_xy] == h->slice_num ? h->top_cbp : -1;
873 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
874 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
875 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08);
876 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
877 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01);
878 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
879 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02);
880 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
883 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
887 cbp_a = (h->left_cbp>>4)&0x03;
888 cbp_b = (h-> top_cbp>>4)&0x03;
891 if( cbp_a > 0 ) ctx++;
892 if( cbp_b > 0 ) ctx += 2;
893 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
897 if( cbp_a == 2 ) ctx++;
898 if( cbp_b == 2 ) ctx += 2;
899 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
901 static int decode_cabac_mb_dqp( H264Context *h) {
902 int ctx= h->last_qscale_diff != 0;
905 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
908 if(val > 102) //prevent infinite loop
913 return (val + 1)>>1 ;
915 return -((val + 1)>>1);
917 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
918 if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
920 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
922 if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
926 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
928 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
929 return 0; /* B_Direct_8x8 */
930 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
931 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
933 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
934 if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
935 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
938 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
939 type += get_cabac( &h->cabac, &h->cabac_state[39] );
943 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
944 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
947 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
948 int refa = h->ref_cache[list][scan8[n] - 1];
949 int refb = h->ref_cache[list][scan8[n] - 8];
953 if( h->slice_type_nos == FF_B_TYPE) {
954 if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
956 if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
965 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
968 if(ref >= 32 /*h->ref_list[list]*/){
975 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
976 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
977 abs( h->mvd_cache[list][scan8[n] - 8][l] );
978 int ctxbase = (l == 0) ? 40 : 47;
980 int ctx = (amvd>2) + (amvd>32);
982 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
987 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
995 while( get_cabac_bypass( &h->cabac ) ) {
999 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
1004 if( get_cabac_bypass( &h->cabac ) )
1008 return get_cabac_bypass_sign( &h->cabac, -mvd );
1011 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
1017 nza = h->left_cbp&0x100;
1018 nzb = h-> top_cbp&0x100;
1020 nza = (h->left_cbp>>(6+idx))&0x01;
1021 nzb = (h-> top_cbp>>(6+idx))&0x01;
1024 assert(cat == 1 || cat == 2 || cat == 4);
1025 nza = h->non_zero_count_cache[scan8[idx] - 1];
1026 nzb = h->non_zero_count_cache[scan8[idx] - 8];
1035 return ctx + 4 * cat;
1038 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
1039 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1040 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1041 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1042 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1045 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 ) {
1046 static const int significant_coeff_flag_offset[2][6] = {
1047 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1048 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1050 static const int last_coeff_flag_offset[2][6] = {
1051 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1052 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1054 static const int coeff_abs_level_m1_offset[6] = {
1055 227+0, 227+10, 227+20, 227+30, 227+39, 426
1057 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1058 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1059 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1060 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1061 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1062 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1063 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1064 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1065 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1067 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1068 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1069 * map node ctx => cabac ctx for level=1 */
1070 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1071 /* map node ctx => cabac ctx for level>1 */
1072 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1073 static const uint8_t coeff_abs_level_transition[2][8] = {
1074 /* update node ctx after decoding a level=1 */
1075 { 1, 2, 3, 3, 4, 5, 6, 7 },
1076 /* update node ctx after decoding a level>1 */
1077 { 4, 4, 4, 4, 5, 6, 7, 7 }
1083 int coeff_count = 0;
1086 uint8_t *significant_coeff_ctx_base;
1087 uint8_t *last_coeff_ctx_base;
1088 uint8_t *abs_level_m1_ctx_base;
1091 #define CABAC_ON_STACK
1093 #ifdef CABAC_ON_STACK
1096 cc.range = h->cabac.range;
1097 cc.low = h->cabac.low;
1098 cc.bytestream= h->cabac.bytestream;
1100 #define CC &h->cabac
1104 /* cat: 0-> DC 16x16 n = 0
1105 * 1-> AC 16x16 n = luma4x4idx
1106 * 2-> Luma4x4 n = luma4x4idx
1107 * 3-> DC Chroma n = iCbCr
1108 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1109 * 5-> Luma8x8 n = 4 * luma8x8idx
1112 /* read coded block flag */
1113 if( is_dc || cat != 5 ) {
1114 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1116 h->non_zero_count_cache[scan8[n]] = 0;
1118 #ifdef CABAC_ON_STACK
1119 h->cabac.range = cc.range ;
1120 h->cabac.low = cc.low ;
1121 h->cabac.bytestream= cc.bytestream;
1127 significant_coeff_ctx_base = h->cabac_state
1128 + significant_coeff_flag_offset[MB_FIELD][cat];
1129 last_coeff_ctx_base = h->cabac_state
1130 + last_coeff_flag_offset[MB_FIELD][cat];
1131 abs_level_m1_ctx_base = h->cabac_state
1132 + coeff_abs_level_m1_offset[cat];
1134 if( !is_dc && cat == 5 ) {
1135 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1136 for(last= 0; last < coefs; last++) { \
1137 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1138 if( get_cabac( CC, sig_ctx )) { \
1139 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1140 index[coeff_count++] = last; \
1141 if( get_cabac( CC, last_ctx ) ) { \
1147 if( last == max_coeff -1 ) {\
1148 index[coeff_count++] = last;\
1150 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1151 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1152 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1154 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1156 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1158 DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1161 assert(coeff_count > 0);
1165 h->cbp_table[h->mb_xy] |= 0x100;
1167 h->cbp_table[h->mb_xy] |= 0x40 << n;
1170 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1172 assert( cat == 1 || cat == 2 || cat == 4 );
1173 h->non_zero_count_cache[scan8[n]] = coeff_count;
1178 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1180 int j= scantable[index[--coeff_count]];
1182 if( get_cabac( CC, ctx ) == 0 ) {
1183 node_ctx = coeff_abs_level_transition[0][node_ctx];
1185 block[j] = get_cabac_bypass_sign( CC, -1);
1187 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1191 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1192 node_ctx = coeff_abs_level_transition[1][node_ctx];
1194 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1198 if( coeff_abs >= 15 ) {
1200 while( get_cabac_bypass( CC ) ) {
1206 coeff_abs += coeff_abs + get_cabac_bypass( CC );
1212 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1214 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1217 } while( coeff_count );
1218 #ifdef CABAC_ON_STACK
1219 h->cabac.range = cc.range ;
1220 h->cabac.low = cc.low ;
1221 h->cabac.bytestream= cc.bytestream;
1227 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1228 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1231 static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1232 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1236 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1238 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1240 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1241 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1245 static inline void compute_mb_neighbors(H264Context *h)
1247 MpegEncContext * const s = &h->s;
1248 const int mb_xy = h->mb_xy;
1249 h->top_mb_xy = mb_xy - s->mb_stride;
1250 h->left_mb_xy[0] = mb_xy - 1;
1252 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride;
1253 const int top_pair_xy = pair_xy - s->mb_stride;
1254 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1255 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1256 const int curr_mb_field_flag = MB_FIELD;
1257 const int bottom = (s->mb_y & 1);
1259 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1260 h->top_mb_xy -= s->mb_stride;
1262 if (!left_mb_field_flag == curr_mb_field_flag) {
1263 h->left_mb_xy[0] = pair_xy - 1;
1265 } else if (FIELD_PICTURE) {
1266 h->top_mb_xy -= s->mb_stride;
1272 * decodes a macroblock
1273 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1275 int ff_h264_decode_mb_cabac(H264Context *h) {
1276 MpegEncContext * const s = &h->s;
1278 int mb_type, partition_count, cbp = 0;
1279 int dct8x8_allowed= h->pps.transform_8x8_mode;
1281 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1283 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1284 if( h->slice_type_nos != FF_I_TYPE ) {
1286 /* a skipped mb needs the aff flag from the following mb */
1287 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1288 predict_field_decoding_flag(h);
1289 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1290 skip = h->next_mb_skipped;
1292 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1293 /* read skip flags */
1295 if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1296 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1297 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1298 if(!h->next_mb_skipped)
1299 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1304 h->cbp_table[mb_xy] = 0;
1305 h->chroma_pred_mode_table[mb_xy] = 0;
1306 h->last_qscale_diff = 0;
1313 if( (s->mb_y&1) == 0 )
1315 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1318 h->prev_mb_skipped = 0;
1320 compute_mb_neighbors(h);
1322 if( h->slice_type_nos == FF_B_TYPE ) {
1323 mb_type = decode_cabac_mb_type_b( h );
1325 partition_count= b_mb_type_info[mb_type].partition_count;
1326 mb_type= b_mb_type_info[mb_type].type;
1329 goto decode_intra_mb;
1331 } else if( h->slice_type_nos == FF_P_TYPE ) {
1332 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1334 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1335 /* P_L0_D16x16, P_8x8 */
1336 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1338 /* P_L0_D8x16, P_L0_D16x8 */
1339 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1341 partition_count= p_mb_type_info[mb_type].partition_count;
1342 mb_type= p_mb_type_info[mb_type].type;
1344 mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1345 goto decode_intra_mb;
1348 mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1349 if(h->slice_type == FF_SI_TYPE && mb_type)
1351 assert(h->slice_type_nos == FF_I_TYPE);
1353 partition_count = 0;
1354 cbp= i_mb_type_info[mb_type].cbp;
1355 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1356 mb_type= i_mb_type_info[mb_type].type;
1359 mb_type |= MB_TYPE_INTERLACED;
1361 h->slice_table[ mb_xy ]= h->slice_num;
1363 if(IS_INTRA_PCM(mb_type)) {
1366 // We assume these blocks are very rare so we do not optimize it.
1367 // FIXME The two following lines get the bitstream position in the cabac
1368 // decode, I think it should be done by a function in cabac.h (or cabac.c).
1369 ptr= h->cabac.bytestream;
1370 if(h->cabac.low&0x1) ptr--;
1372 if(h->cabac.low&0x1FF) ptr--;
1375 // The pixels are stored in the same order as levels in h->mb array.
1376 memcpy(h->mb, ptr, 256); ptr+=256;
1378 memcpy(h->mb+128, ptr, 128); ptr+=128;
1381 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1383 // All blocks are present
1384 h->cbp_table[mb_xy] = 0x1ef;
1385 h->chroma_pred_mode_table[mb_xy] = 0;
1386 // In deblocking, the quantizer is 0
1387 s->current_picture.qscale_table[mb_xy]= 0;
1388 // All coeffs are present
1389 memset(h->non_zero_count[mb_xy], 16, 32);
1390 s->current_picture.mb_type[mb_xy]= mb_type;
1391 h->last_qscale_diff = 0;
1396 h->ref_count[0] <<= 1;
1397 h->ref_count[1] <<= 1;
1400 fill_decode_caches(h, mb_type);
1402 if( IS_INTRA( mb_type ) ) {
1404 if( IS_INTRA4x4( mb_type ) ) {
1405 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
1406 mb_type |= MB_TYPE_8x8DCT;
1407 for( i = 0; i < 16; i+=4 ) {
1408 int pred = pred_intra_mode( h, i );
1409 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1410 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1413 for( i = 0; i < 16; i++ ) {
1414 int pred = pred_intra_mode( h, i );
1415 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1417 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1420 ff_h264_write_back_intra_pred_mode(h);
1421 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1423 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1424 if( h->intra16x16_pred_mode < 0 ) return -1;
1427 h->chroma_pred_mode_table[mb_xy] =
1428 pred_mode = decode_cabac_mb_chroma_pre_mode( h );
1430 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1431 if( pred_mode < 0 ) return -1;
1432 h->chroma_pred_mode= pred_mode;
1434 } else if( partition_count == 4 ) {
1435 int i, j, sub_partition_count[4], list, ref[2][4];
1437 if( h->slice_type_nos == FF_B_TYPE ) {
1438 for( i = 0; i < 4; i++ ) {
1439 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1440 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1441 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1443 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1444 h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1445 ff_h264_pred_direct_motion(h, &mb_type);
1446 h->ref_cache[0][scan8[4]] =
1447 h->ref_cache[1][scan8[4]] =
1448 h->ref_cache[0][scan8[12]] =
1449 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1450 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
1451 for( i = 0; i < 4; i++ )
1452 if( IS_DIRECT(h->sub_mb_type[i]) )
1453 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
1457 for( i = 0; i < 4; i++ ) {
1458 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1459 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1460 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1464 for( list = 0; list < h->list_count; list++ ) {
1465 for( i = 0; i < 4; i++ ) {
1466 if(IS_DIRECT(h->sub_mb_type[i])) continue;
1467 if(IS_DIR(h->sub_mb_type[i], 0, list)){
1468 if( h->ref_count[list] > 1 ){
1469 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1470 if(ref[list][i] >= (unsigned)h->ref_count[list]){
1471 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1479 h->ref_cache[list][ scan8[4*i]+1 ]=
1480 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1485 dct8x8_allowed = get_dct8x8_allowed(h);
1487 for(list=0; list<h->list_count; list++){
1489 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ];
1490 if(IS_DIRECT(h->sub_mb_type[i])){
1491 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1495 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1496 const int sub_mb_type= h->sub_mb_type[i];
1497 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1498 for(j=0; j<sub_partition_count[i]; j++){
1501 const int index= 4*i + block_width*j;
1502 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1503 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1504 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1506 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1507 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1508 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1510 if(IS_SUB_8X8(sub_mb_type)){
1512 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1514 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1517 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1519 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1520 }else if(IS_SUB_8X4(sub_mb_type)){
1521 mv_cache[ 1 ][0]= mx;
1522 mv_cache[ 1 ][1]= my;
1524 mvd_cache[ 1 ][0]= mx - mpx;
1525 mvd_cache[ 1 ][1]= my - mpy;
1526 }else if(IS_SUB_4X8(sub_mb_type)){
1527 mv_cache[ 8 ][0]= mx;
1528 mv_cache[ 8 ][1]= my;
1530 mvd_cache[ 8 ][0]= mx - mpx;
1531 mvd_cache[ 8 ][1]= my - mpy;
1533 mv_cache[ 0 ][0]= mx;
1534 mv_cache[ 0 ][1]= my;
1536 mvd_cache[ 0 ][0]= mx - mpx;
1537 mvd_cache[ 0 ][1]= my - mpy;
1540 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1541 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1542 p[0] = p[1] = p[8] = p[9] = 0;
1543 pd[0]= pd[1]= pd[8]= pd[9]= 0;
1547 } else if( IS_DIRECT(mb_type) ) {
1548 ff_h264_pred_direct_motion(h, &mb_type);
1549 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1550 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1551 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1553 int list, mx, my, i, mpx, mpy;
1554 if(IS_16X16(mb_type)){
1555 for(list=0; list<h->list_count; list++){
1556 if(IS_DIR(mb_type, 0, list)){
1558 if(h->ref_count[list] > 1){
1559 ref= decode_cabac_mb_ref(h, list, 0);
1560 if(ref >= (unsigned)h->ref_count[list]){
1561 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1566 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1568 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
1570 for(list=0; list<h->list_count; list++){
1571 if(IS_DIR(mb_type, 0, list)){
1572 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1574 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1575 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1576 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1578 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1579 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1581 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1584 else if(IS_16X8(mb_type)){
1585 for(list=0; list<h->list_count; list++){
1587 if(IS_DIR(mb_type, i, list)){
1589 if(h->ref_count[list] > 1){
1590 ref= decode_cabac_mb_ref( h, list, 8*i );
1591 if(ref >= (unsigned)h->ref_count[list]){
1592 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1597 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1599 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1602 for(list=0; list<h->list_count; list++){
1604 if(IS_DIR(mb_type, i, list)){
1605 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1606 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1607 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1608 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1610 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1611 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1613 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1614 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1619 assert(IS_8X16(mb_type));
1620 for(list=0; list<h->list_count; list++){
1622 if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1624 if(h->ref_count[list] > 1){
1625 ref= decode_cabac_mb_ref( h, list, 4*i );
1626 if(ref >= (unsigned)h->ref_count[list]){
1627 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1632 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1634 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1637 for(list=0; list<h->list_count; list++){
1639 if(IS_DIR(mb_type, i, list)){
1640 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1641 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1642 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1644 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1645 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1646 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1648 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1649 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1656 if( IS_INTER( mb_type ) ) {
1657 h->chroma_pred_mode_table[mb_xy] = 0;
1658 write_back_motion( h, mb_type );
1661 if( !IS_INTRA16x16( mb_type ) ) {
1662 cbp = decode_cabac_mb_cbp_luma( h );
1664 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1667 h->cbp_table[mb_xy] = h->cbp = cbp;
1669 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1670 if( decode_cabac_mb_transform_size( h ) )
1671 mb_type |= MB_TYPE_8x8DCT;
1673 s->current_picture.mb_type[mb_xy]= mb_type;
1675 if( cbp || IS_INTRA16x16( mb_type ) ) {
1676 const uint8_t *scan, *scan8x8, *dc_scan;
1677 const uint32_t *qmul;
1680 if(IS_INTERLACED(mb_type)){
1681 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1682 scan= s->qscale ? h->field_scan : h->field_scan_q0;
1683 dc_scan= luma_dc_field_scan;
1685 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1686 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1687 dc_scan= luma_dc_zigzag_scan;
1690 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
1691 if( dqp == INT_MIN ){
1692 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1696 if(((unsigned)s->qscale) > 51){
1697 if(s->qscale<0) s->qscale+= 52;
1698 else s->qscale-= 52;
1700 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1701 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1703 if( IS_INTRA16x16( mb_type ) ) {
1705 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1706 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1709 qmul = h->dequant4_coeff[0][s->qscale];
1710 for( i = 0; i < 16; i++ ) {
1711 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1712 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1715 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1719 for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1720 if( cbp & (1<<i8x8) ) {
1721 if( IS_8x8DCT(mb_type) ) {
1722 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1723 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1725 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1726 for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1727 const int index = 4*i8x8 + i4x4;
1728 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1730 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1731 //STOP_TIMER("decode_residual")
1735 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1736 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1743 for( c = 0; c < 2; c++ ) {
1744 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1745 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1751 for( c = 0; c < 2; c++ ) {
1752 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1753 for( i = 0; i < 4; i++ ) {
1754 const int index = 16 + 4 * c + i;
1755 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1756 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1760 uint8_t * const nnz= &h->non_zero_count_cache[0];
1761 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1762 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1765 uint8_t * const nnz= &h->non_zero_count_cache[0];
1766 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1767 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1768 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1769 h->last_qscale_diff = 0;
1772 s->current_picture.qscale_table[mb_xy]= s->qscale;
1773 write_back_non_zero_count(h);
1776 h->ref_count[0] >>= 1;
1777 h->ref_count[1] >>= 1;