Mercurial > libavcodec.hg
annotate h264_cabac.c @ 10893:2aafcafbe1f0 libavcodec
Replace cabac checks in inline functions from h264.h with constants.
No benchmark because its just replacing variables with litteral constants
(so no risk for slowdown outside gcc silliness) and i need sleep.
author | michael |
---|---|
date | Sat, 16 Jan 2010 05:41:33 +0000 |
parents | 7101061bfa0f |
children | 1b5fba731e24 |
rev | line source |
---|---|
10869 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
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. | |
11 * | |
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. | |
16 * | |
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 | |
20 */ | |
21 | |
22 /** | |
23 * @file libavcodec/h264_cabac.c | |
24 * H.264 / AVC / MPEG4 part10 cabac decoding. | |
25 * @author Michael Niedermayer <michaelni@gmx.at> | |
26 */ | |
27 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10869
diff
changeset
|
28 #define CABAC 1 |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10869
diff
changeset
|
29 |
10869 | 30 #include "internal.h" |
31 #include "dsputil.h" | |
32 #include "avcodec.h" | |
33 #include "h264.h" | |
34 #include "h264data.h" | |
35 #include "h264_mvpred.h" | |
36 #include "golomb.h" | |
37 | |
38 #include "cabac.h" | |
39 #if ARCH_X86 | |
40 #include "x86/h264_i386.h" | |
41 #endif | |
42 | |
43 //#undef NDEBUG | |
44 #include <assert.h> | |
45 | |
46 /* Cabac pre state table */ | |
47 | |
48 static const int8_t cabac_context_init_I[460][2] = | |
49 { | |
50 /* 0 - 10 */ | |
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 }, | |
54 | |
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 }, | |
59 { 0, 0 }, | |
60 | |
61 /* 24- 39 */ | |
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 }, | |
66 | |
67 /* 40 - 53 */ | |
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 }, | |
71 { 0, 0 }, { 0, 0 }, | |
72 | |
73 /* 54 - 59 */ | |
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
75 { 0, 0 }, { 0, 0 }, | |
76 | |
77 /* 60 - 69 */ | |
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
80 { 13, 41 }, { 3, 62 }, | |
81 | |
82 /* 70 -> 87 */ | |
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 }, | |
88 | |
89 /* 88 -> 104 */ | |
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 }, | |
94 { -22, 125 }, | |
95 | |
96 /* 105 -> 135 */ | |
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 }, | |
105 | |
106 /* 136 -> 165 */ | |
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 }, | |
115 | |
116 /* 166 -> 196 */ | |
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 }, | |
125 | |
126 /* 197 -> 226 */ | |
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 }, | |
135 | |
136 /* 227 -> 251 */ | |
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 }, | |
143 { -4, 65 }, | |
144 | |
145 /* 252 -> 275 */ | |
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 }, | |
152 | |
153 /* 276 a bit special (not used, bypass is used instead) */ | |
154 { 0, 0 }, | |
155 | |
156 /* 277 -> 307 */ | |
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 }, | |
165 | |
166 /* 308 -> 337 */ | |
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 }, | |
175 | |
176 /* 338 -> 368 */ | |
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 }, | |
185 | |
186 /* 369 -> 398 */ | |
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 }, | |
195 | |
196 /* 399 -> 435 */ | |
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 }, | |
207 | |
208 /* 436 -> 459 */ | |
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 } | |
215 }; | |
216 | |
217 static const int8_t cabac_context_init_PB[3][460][2] = | |
218 { | |
219 /* i_cabac_init_idc == 0 */ | |
220 { | |
221 /* 0 - 10 */ | |
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 }, | |
225 | |
226 /* 11 - 23 */ | |
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 }, | |
230 { 17, 50 }, | |
231 | |
232 /* 24 - 39 */ | |
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 }, | |
237 | |
238 /* 40 - 53 */ | |
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 }, | |
243 | |
244 /* 54 - 59 */ | |
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 }, | |
246 { -7, 72 }, { 1, 58 }, | |
247 | |
248 /* 60 - 69 */ | |
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
251 { 13, 41 }, { 3, 62 }, | |
252 | |
253 /* 70 - 87 */ | |
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 }, | |
263 | |
264 /* 105 -> 165 */ | |
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 }, | |
280 { 9, 69 }, | |
281 | |
282 /* 166 - 226 */ | |
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 }, | |
298 { -9, 108 }, | |
299 | |
300 /* 227 - 275 */ | |
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 }, | |
313 { -8, 85 }, | |
314 | |
315 /* 276 a bit special (not used, bypass is used instead) */ | |
316 { 0, 0 }, | |
317 | |
318 /* 277 - 337 */ | |
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 }, | |
334 { 26, 43 }, | |
335 | |
336 /* 338 - 398 */ | |
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 }, | |
352 { 11, 86 }, | |
353 | |
354 /* 399 - 435 */ | |
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 }, | |
365 | |
366 /* 436 - 459 */ | |
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 }, | |
373 }, | |
374 | |
375 /* i_cabac_init_idc == 1 */ | |
376 { | |
377 /* 0 - 10 */ | |
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 }, | |
381 | |
382 /* 11 - 23 */ | |
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 }, | |
386 { 10, 54 }, | |
387 | |
388 /* 24 - 39 */ | |
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 }, | |
393 | |
394 /* 40 - 53 */ | |
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 }, | |
399 | |
400 /* 54 - 59 */ | |
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 }, | |
402 { -5, 72 },{ 0, 61 }, | |
403 | |
404 /* 60 - 69 */ | |
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
407 { 13, 41 }, { 3, 62 }, | |
408 | |
409 /* 70 - 104 */ | |
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 }, | |
419 | |
420 /* 105 -> 165 */ | |
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 }, | |
436 { 0, 89 }, | |
437 | |
438 /* 166 - 226 */ | |
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 }, | |
454 { -10, 116 }, | |
455 | |
456 /* 227 - 275 */ | |
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 }, | |
469 { -4, 78 }, | |
470 | |
471 /* 276 a bit special (not used, bypass is used instead) */ | |
472 { 0, 0 }, | |
473 | |
474 /* 277 - 337 */ | |
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 }, | |
490 { 18, 50 }, | |
491 | |
492 /* 338 - 398 */ | |
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 }, | |
508 { 11, 83 }, | |
509 | |
510 /* 399 - 435 */ | |
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 }, | |
521 | |
522 /* 436 - 459 */ | |
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 }, | |
529 }, | |
530 | |
531 /* i_cabac_init_idc == 2 */ | |
532 { | |
533 /* 0 - 10 */ | |
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 }, | |
537 | |
538 /* 11 - 23 */ | |
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 }, | |
542 { 14, 57 }, | |
543 | |
544 /* 24 - 39 */ | |
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 }, | |
549 | |
550 /* 40 - 53 */ | |
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 }, | |
555 | |
556 /* 54 - 59 */ | |
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 }, | |
558 { -7, 50 },{ 1, 60 }, | |
559 | |
560 /* 60 - 69 */ | |
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
563 { 13, 41 }, { 3, 62 }, | |
564 | |
565 /* 70 - 104 */ | |
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 }, | |
575 | |
576 /* 105 -> 165 */ | |
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 }, | |
592 { -22, 127 }, | |
593 | |
594 /* 166 - 226 */ | |
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 }, | |
610 { -24, 127 }, | |
611 | |
612 /* 227 - 275 */ | |
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 }, | |
625 { -10, 87 }, | |
626 | |
627 /* 276 a bit special (not used, bypass is used instead) */ | |
628 { 0, 0 }, | |
629 | |
630 /* 277 - 337 */ | |
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 }, | |
646 { 25, 42 }, | |
647 | |
648 /* 338 - 398 */ | |
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 }, | |
664 { 25, 61 }, | |
665 | |
666 /* 399 - 435 */ | |
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 }, | |
677 | |
678 /* 436 - 459 */ | |
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 }, | |
685 } | |
686 }; | |
687 | |
688 void ff_h264_init_cabac_states(H264Context *h) { | |
689 MpegEncContext * const s = &h->s; | |
690 int i; | |
691 | |
692 /* calculate pre-state */ | |
693 for( i= 0; i < 460; i++ ) { | |
694 int pre; | |
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 ); | |
697 else | |
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 ); | |
699 | |
700 if( pre <= 63 ) | |
701 h->cabac_state[i] = 2 * ( 63 - pre ) + 0; | |
702 else | |
703 h->cabac_state[i] = 2 * ( pre - 64 ) + 1; | |
704 } | |
705 } | |
706 | |
707 static int decode_cabac_field_decoding_flag(H264Context *h) { | |
708 MpegEncContext * const s = &h->s; | |
709 const int mb_x = s->mb_x; | |
710 const int mb_y = s->mb_y & ~1; | |
711 const int mba_xy = mb_x - 1 + mb_y *s->mb_stride; | |
712 const int mbb_xy = mb_x + (mb_y-2)*s->mb_stride; | |
713 | |
714 unsigned int ctx = 0; | |
715 | |
716 if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) { | |
717 ctx += 1; | |
718 } | |
719 if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) { | |
720 ctx += 1; | |
721 } | |
722 | |
723 return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] ); | |
724 } | |
725 | |
726 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { | |
727 uint8_t *state= &h->cabac_state[ctx_base]; | |
728 int mb_type; | |
729 | |
730 if(intra_slice){ | |
731 MpegEncContext * const s = &h->s; | |
732 const int mba_xy = h->left_mb_xy[0]; | |
733 const int mbb_xy = h->top_mb_xy; | |
734 int ctx=0; | |
735 if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) ) | |
736 ctx++; | |
737 if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) ) | |
738 ctx++; | |
739 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) | |
740 return 0; /* I4x4 */ | |
741 state += 2; | |
742 }else{ | |
743 if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 ) | |
744 return 0; /* I4x4 */ | |
745 } | |
746 | |
747 if( get_cabac_terminate( &h->cabac ) ) | |
748 return 25; /* PCM */ | |
749 | |
750 mb_type = 1; /* I16x16 */ | |
751 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */ | |
752 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */ | |
753 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] ); | |
754 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] ); | |
755 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); | |
756 return mb_type; | |
757 } | |
758 | |
759 static int decode_cabac_mb_type_b( H264Context *h ) { | |
760 MpegEncContext * const s = &h->s; | |
761 | |
762 const int mba_xy = h->left_mb_xy[0]; | |
763 const int mbb_xy = h->top_mb_xy; | |
764 int ctx = 0; | |
765 int bits; | |
766 assert(h->slice_type_nos == FF_B_TYPE); | |
767 | |
768 if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) ) | |
769 ctx++; | |
770 if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) ) | |
771 ctx++; | |
772 | |
773 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ) | |
774 return 0; /* B_Direct_16x16 */ | |
775 | |
776 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) { | |
777 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */ | |
778 } | |
779 | |
780 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3; | |
781 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2; | |
782 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1; | |
783 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); | |
784 if( bits < 8 ) | |
785 return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ | |
786 else if( bits == 13 ) { | |
787 return decode_cabac_intra_mb_type(h, 32, 0) + 23; | |
788 } else if( bits == 14 ) | |
789 return 11; /* B_L1_L0_8x16 */ | |
790 else if( bits == 15 ) | |
791 return 22; /* B_8x8 */ | |
792 | |
793 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); | |
794 return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */ | |
795 } | |
796 | |
797 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) { | |
798 MpegEncContext * const s = &h->s; | |
799 int mba_xy, mbb_xy; | |
800 int ctx = 0; | |
801 | |
802 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? | |
803 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
804 mba_xy = mb_xy - 1; | |
805 if( (mb_y&1) | |
806 && h->slice_table[mba_xy] == h->slice_num | |
807 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
808 mba_xy += s->mb_stride; | |
809 if( MB_FIELD ){ | |
810 mbb_xy = mb_xy - s->mb_stride; | |
811 if( !(mb_y&1) | |
812 && h->slice_table[mbb_xy] == h->slice_num | |
813 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
814 mbb_xy -= s->mb_stride; | |
815 }else | |
816 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
817 }else{ | |
818 int mb_xy = h->mb_xy; | |
819 mba_xy = mb_xy - 1; | |
820 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE); | |
821 } | |
822 | |
823 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )) | |
824 ctx++; | |
825 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )) | |
826 ctx++; | |
827 | |
828 if( h->slice_type_nos == FF_B_TYPE ) | |
829 ctx += 13; | |
830 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] ); | |
831 } | |
832 | |
833 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) { | |
834 int mode = 0; | |
835 | |
836 if( get_cabac( &h->cabac, &h->cabac_state[68] ) ) | |
837 return pred_mode; | |
838 | |
839 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
840 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
841 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
842 | |
843 if( mode >= pred_mode ) | |
844 return mode + 1; | |
845 else | |
846 return mode; | |
847 } | |
848 | |
849 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { | |
850 const int mba_xy = h->left_mb_xy[0]; | |
851 const int mbb_xy = h->top_mb_xy; | |
852 | |
853 int ctx = 0; | |
854 | |
855 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ | |
856 if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 ) | |
857 ctx++; | |
858 | |
859 if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 ) | |
860 ctx++; | |
861 | |
862 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) | |
863 return 0; | |
864 | |
865 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
866 return 1; | |
867 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
868 return 2; | |
869 else | |
870 return 3; | |
871 } | |
872 | |
873 static int decode_cabac_mb_cbp_luma( H264Context *h) { | |
874 int cbp_b, cbp_a, ctx, cbp = 0; | |
875 | |
876 cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1; | |
877 cbp_b = h->slice_table[h->top_mb_xy] == h->slice_num ? h->top_cbp : -1; | |
878 | |
879 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04); | |
880 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]); | |
881 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08); | |
882 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1; | |
883 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01); | |
884 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2; | |
885 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02); | |
886 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3; | |
887 return cbp; | |
888 } | |
889 static int decode_cabac_mb_cbp_chroma( H264Context *h) { | |
890 int ctx; | |
891 int cbp_a, cbp_b; | |
892 | |
893 cbp_a = (h->left_cbp>>4)&0x03; | |
894 cbp_b = (h-> top_cbp>>4)&0x03; | |
895 | |
896 ctx = 0; | |
897 if( cbp_a > 0 ) ctx++; | |
898 if( cbp_b > 0 ) ctx += 2; | |
899 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 ) | |
900 return 0; | |
901 | |
902 ctx = 4; | |
903 if( cbp_a == 2 ) ctx++; | |
904 if( cbp_b == 2 ) ctx += 2; | |
905 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ); | |
906 } | |
907 static int decode_cabac_mb_dqp( H264Context *h) { | |
908 int ctx= h->last_qscale_diff != 0; | |
909 int val = 0; | |
910 | |
911 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) { | |
912 ctx= 2+(ctx>>1); | |
913 val++; | |
914 if(val > 102) //prevent infinite loop | |
915 return INT_MIN; | |
916 } | |
917 | |
918 if( val&0x01 ) | |
919 return (val + 1)>>1 ; | |
920 else | |
921 return -((val + 1)>>1); | |
922 } | |
923 static int decode_cabac_p_mb_sub_type( H264Context *h ) { | |
924 if( get_cabac( &h->cabac, &h->cabac_state[21] ) ) | |
925 return 0; /* 8x8 */ | |
926 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) ) | |
927 return 1; /* 8x4 */ | |
928 if( get_cabac( &h->cabac, &h->cabac_state[23] ) ) | |
929 return 2; /* 4x8 */ | |
930 return 3; /* 4x4 */ | |
931 } | |
932 static int decode_cabac_b_mb_sub_type( H264Context *h ) { | |
933 int type; | |
934 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) ) | |
935 return 0; /* B_Direct_8x8 */ | |
936 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) ) | |
937 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */ | |
938 type = 3; | |
939 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) { | |
940 if( get_cabac( &h->cabac, &h->cabac_state[39] ) ) | |
941 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */ | |
942 type += 4; | |
943 } | |
944 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] ); | |
945 type += get_cabac( &h->cabac, &h->cabac_state[39] ); | |
946 return type; | |
947 } | |
948 | |
949 static inline int decode_cabac_mb_transform_size( H264Context *h ) { | |
950 return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); | |
951 } | |
952 | |
953 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) { | |
954 int refa = h->ref_cache[list][scan8[n] - 1]; | |
955 int refb = h->ref_cache[list][scan8[n] - 8]; | |
956 int ref = 0; | |
957 int ctx = 0; | |
958 | |
959 if( h->slice_type_nos == FF_B_TYPE) { | |
960 if( refa > 0 && !h->direct_cache[scan8[n] - 1] ) | |
961 ctx++; | |
962 if( refb > 0 && !h->direct_cache[scan8[n] - 8] ) | |
963 ctx += 2; | |
964 } else { | |
965 if( refa > 0 ) | |
966 ctx++; | |
967 if( refb > 0 ) | |
968 ctx += 2; | |
969 } | |
970 | |
971 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) { | |
972 ref++; | |
973 ctx = (ctx>>2)+4; | |
974 if(ref >= 32 /*h->ref_list[list]*/){ | |
975 return -1; | |
976 } | |
977 } | |
978 return ref; | |
979 } | |
980 | |
981 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) { | |
982 int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) + | |
983 abs( h->mvd_cache[list][scan8[n] - 8][l] ); | |
984 int ctxbase = (l == 0) ? 40 : 47; | |
985 int mvd; | |
986 int ctx = (amvd>2) + (amvd>32); | |
987 | |
988 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx])) | |
989 return 0; | |
990 | |
991 mvd= 1; | |
992 ctx= 3; | |
993 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) { | |
994 mvd++; | |
995 if( ctx < 6 ) | |
996 ctx++; | |
997 } | |
998 | |
999 if( mvd >= 9 ) { | |
1000 int k = 3; | |
1001 while( get_cabac_bypass( &h->cabac ) ) { | |
1002 mvd += 1 << k; | |
1003 k++; | |
1004 if(k>24){ | |
1005 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); | |
1006 return INT_MIN; | |
1007 } | |
1008 } | |
1009 while( k-- ) { | |
1010 if( get_cabac_bypass( &h->cabac ) ) | |
1011 mvd += 1 << k; | |
1012 } | |
1013 } | |
1014 return get_cabac_bypass_sign( &h->cabac, -mvd ); | |
1015 } | |
1016 | |
1017 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) { | |
1018 int nza, nzb; | |
1019 int ctx = 0; | |
1020 | |
1021 if( is_dc ) { | |
1022 if( cat == 0 ) { | |
1023 nza = h->left_cbp&0x100; | |
1024 nzb = h-> top_cbp&0x100; | |
1025 } else { | |
1026 nza = (h->left_cbp>>(6+idx))&0x01; | |
1027 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
1028 } | |
1029 } else { | |
1030 assert(cat == 1 || cat == 2 || cat == 4); | |
1031 nza = h->non_zero_count_cache[scan8[idx] - 1]; | |
1032 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
1033 } | |
1034 | |
1035 if( nza > 0 ) | |
1036 ctx++; | |
1037 | |
1038 if( nzb > 0 ) | |
1039 ctx += 2; | |
1040 | |
1041 return ctx + 4 * cat; | |
1042 } | |
1043 | |
1044 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8[63]) = { | |
1045 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
1046 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
1047 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
1048 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
1049 }; | |
1050 | |
1051 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 ) { | |
1052 static const int significant_coeff_flag_offset[2][6] = { | |
1053 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
1054 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
1055 }; | |
1056 static const int last_coeff_flag_offset[2][6] = { | |
1057 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
1058 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
1059 }; | |
1060 static const int coeff_abs_level_m1_offset[6] = { | |
1061 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
1062 }; | |
1063 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { | |
1064 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, | |
1065 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, | |
1066 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
1067 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, | |
1068 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
1069 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
1070 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
1071 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
1072 }; | |
1073 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0). | |
1074 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter). | |
1075 * map node ctx => cabac ctx for level=1 */ | |
1076 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 }; | |
1077 /* map node ctx => cabac ctx for level>1 */ | |
1078 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 }; | |
1079 static const uint8_t coeff_abs_level_transition[2][8] = { | |
1080 /* update node ctx after decoding a level=1 */ | |
1081 { 1, 2, 3, 3, 4, 5, 6, 7 }, | |
1082 /* update node ctx after decoding a level>1 */ | |
1083 { 4, 4, 4, 4, 5, 6, 7, 7 } | |
1084 }; | |
1085 | |
1086 int index[64]; | |
1087 | |
1088 int av_unused last; | |
1089 int coeff_count = 0; | |
1090 int node_ctx = 0; | |
1091 | |
1092 uint8_t *significant_coeff_ctx_base; | |
1093 uint8_t *last_coeff_ctx_base; | |
1094 uint8_t *abs_level_m1_ctx_base; | |
1095 | |
1096 #if !ARCH_X86 | |
1097 #define CABAC_ON_STACK | |
1098 #endif | |
1099 #ifdef CABAC_ON_STACK | |
1100 #define CC &cc | |
1101 CABACContext cc; | |
1102 cc.range = h->cabac.range; | |
1103 cc.low = h->cabac.low; | |
1104 cc.bytestream= h->cabac.bytestream; | |
1105 #else | |
1106 #define CC &h->cabac | |
1107 #endif | |
1108 | |
1109 | |
1110 /* cat: 0-> DC 16x16 n = 0 | |
1111 * 1-> AC 16x16 n = luma4x4idx | |
1112 * 2-> Luma4x4 n = luma4x4idx | |
1113 * 3-> DC Chroma n = iCbCr | |
1114 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx | |
1115 * 5-> Luma8x8 n = 4 * luma8x8idx | |
1116 */ | |
1117 | |
1118 /* read coded block flag */ | |
1119 if( is_dc || cat != 5 ) { | |
1120 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) { | |
1121 if( !is_dc ) | |
1122 h->non_zero_count_cache[scan8[n]] = 0; | |
1123 | |
1124 #ifdef CABAC_ON_STACK | |
1125 h->cabac.range = cc.range ; | |
1126 h->cabac.low = cc.low ; | |
1127 h->cabac.bytestream= cc.bytestream; | |
1128 #endif | |
1129 return; | |
1130 } | |
1131 } | |
1132 | |
1133 significant_coeff_ctx_base = h->cabac_state | |
1134 + significant_coeff_flag_offset[MB_FIELD][cat]; | |
1135 last_coeff_ctx_base = h->cabac_state | |
1136 + last_coeff_flag_offset[MB_FIELD][cat]; | |
1137 abs_level_m1_ctx_base = h->cabac_state | |
1138 + coeff_abs_level_m1_offset[cat]; | |
1139 | |
1140 if( !is_dc && cat == 5 ) { | |
1141 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
1142 for(last= 0; last < coefs; last++) { \ | |
1143 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \ | |
1144 if( get_cabac( CC, sig_ctx )) { \ | |
1145 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ | |
1146 index[coeff_count++] = last; \ | |
1147 if( get_cabac( CC, last_ctx ) ) { \ | |
1148 last= max_coeff; \ | |
1149 break; \ | |
1150 } \ | |
1151 } \ | |
1152 }\ | |
1153 if( last == max_coeff -1 ) {\ | |
1154 index[coeff_count++] = last;\ | |
1155 } | |
1156 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; | |
1157 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) | |
1158 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); | |
1159 } else { | |
1160 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
1161 #else | |
1162 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); | |
1163 } else { | |
1164 DECODE_SIGNIFICANCE( max_coeff - 1, last, last ); | |
1165 #endif | |
1166 } | |
1167 assert(coeff_count > 0); | |
1168 | |
1169 if( is_dc ) { | |
1170 if( cat == 0 ) | |
1171 h->cbp_table[h->mb_xy] |= 0x100; | |
1172 else | |
1173 h->cbp_table[h->mb_xy] |= 0x40 << n; | |
1174 } else { | |
1175 if( cat == 5 ) | |
1176 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); | |
1177 else { | |
1178 assert( cat == 1 || cat == 2 || cat == 4 ); | |
1179 h->non_zero_count_cache[scan8[n]] = coeff_count; | |
1180 } | |
1181 } | |
1182 | |
1183 do { | |
1184 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1185 | |
1186 int j= scantable[index[--coeff_count]]; | |
1187 | |
1188 if( get_cabac( CC, ctx ) == 0 ) { | |
1189 node_ctx = coeff_abs_level_transition[0][node_ctx]; | |
1190 if( is_dc ) { | |
1191 block[j] = get_cabac_bypass_sign( CC, -1); | |
1192 }else{ | |
1193 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; | |
1194 } | |
1195 } else { | |
1196 int coeff_abs = 2; | |
1197 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1198 node_ctx = coeff_abs_level_transition[1][node_ctx]; | |
1199 | |
1200 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { | |
1201 coeff_abs++; | |
1202 } | |
1203 | |
1204 if( coeff_abs >= 15 ) { | |
1205 int j = 0; | |
1206 while( get_cabac_bypass( CC ) ) { | |
1207 j++; | |
1208 } | |
1209 | |
1210 coeff_abs=1; | |
1211 while( j-- ) { | |
1212 coeff_abs += coeff_abs + get_cabac_bypass( CC ); | |
1213 } | |
1214 coeff_abs+= 14; | |
1215 } | |
1216 | |
1217 if( is_dc ) { | |
1218 block[j] = get_cabac_bypass_sign( CC, -coeff_abs ); | |
1219 }else{ | |
1220 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6; | |
1221 } | |
1222 } | |
1223 } while( coeff_count ); | |
1224 #ifdef CABAC_ON_STACK | |
1225 h->cabac.range = cc.range ; | |
1226 h->cabac.low = cc.low ; | |
1227 h->cabac.bytestream= cc.bytestream; | |
1228 #endif | |
1229 | |
1230 } | |
1231 | |
1232 #if !CONFIG_SMALL | |
1233 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 ) { | |
1234 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1); | |
1235 } | |
1236 | |
1237 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 ) { | |
1238 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0); | |
1239 } | |
1240 #endif | |
1241 | |
1242 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) { | |
1243 #if CONFIG_SMALL | |
1244 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3); | |
1245 #else | |
1246 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff); | |
1247 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff); | |
1248 #endif | |
1249 } | |
1250 | |
1251 static inline void compute_mb_neighbors(H264Context *h) | |
1252 { | |
1253 MpegEncContext * const s = &h->s; | |
1254 const int mb_xy = h->mb_xy; | |
1255 h->top_mb_xy = mb_xy - s->mb_stride; | |
1256 h->left_mb_xy[0] = mb_xy - 1; | |
1257 if(FRAME_MBAFF){ | |
1258 const int pair_xy = s->mb_x + (s->mb_y & ~1)*s->mb_stride; | |
1259 const int top_pair_xy = pair_xy - s->mb_stride; | |
1260 const int top_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]); | |
1261 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]); | |
1262 const int curr_mb_field_flag = MB_FIELD; | |
1263 const int bottom = (s->mb_y & 1); | |
1264 | |
1265 if (curr_mb_field_flag && (bottom || top_mb_field_flag)){ | |
1266 h->top_mb_xy -= s->mb_stride; | |
1267 } | |
1268 if (!left_mb_field_flag == curr_mb_field_flag) { | |
1269 h->left_mb_xy[0] = pair_xy - 1; | |
1270 } | |
1271 } else if (FIELD_PICTURE) { | |
1272 h->top_mb_xy -= s->mb_stride; | |
1273 } | |
1274 return; | |
1275 } | |
1276 | |
1277 /** | |
1278 * decodes a macroblock | |
1279 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
1280 */ | |
1281 int ff_h264_decode_mb_cabac(H264Context *h) { | |
1282 MpegEncContext * const s = &h->s; | |
1283 int mb_xy; | |
1284 int mb_type, partition_count, cbp = 0; | |
1285 int dct8x8_allowed= h->pps.transform_8x8_mode; | |
1286 | |
1287 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1288 | |
1289 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); | |
1290 if( h->slice_type_nos != FF_I_TYPE ) { | |
1291 int skip; | |
1292 /* a skipped mb needs the aff flag from the following mb */ | |
1293 if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 ) | |
1294 predict_field_decoding_flag(h); | |
1295 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
1296 skip = h->next_mb_skipped; | |
1297 else | |
1298 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1299 /* read skip flags */ | |
1300 if( skip ) { | |
1301 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
1302 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
1303 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
1304 if(!h->next_mb_skipped) | |
1305 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1306 } | |
1307 | |
1308 decode_mb_skip(h); | |
1309 | |
1310 h->cbp_table[mb_xy] = 0; | |
1311 h->chroma_pred_mode_table[mb_xy] = 0; | |
1312 h->last_qscale_diff = 0; | |
1313 | |
1314 return 0; | |
1315 | |
1316 } | |
1317 } | |
1318 if(FRAME_MBAFF){ | |
1319 if( (s->mb_y&1) == 0 ) | |
1320 h->mb_mbaff = | |
1321 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1322 } | |
1323 | |
1324 h->prev_mb_skipped = 0; | |
1325 | |
1326 compute_mb_neighbors(h); | |
1327 | |
1328 if( h->slice_type_nos == FF_B_TYPE ) { | |
1329 mb_type = decode_cabac_mb_type_b( h ); | |
1330 if( mb_type < 23 ){ | |
1331 partition_count= b_mb_type_info[mb_type].partition_count; | |
1332 mb_type= b_mb_type_info[mb_type].type; | |
1333 }else{ | |
1334 mb_type -= 23; | |
1335 goto decode_intra_mb; | |
1336 } | |
1337 } else if( h->slice_type_nos == FF_P_TYPE ) { | |
1338 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { | |
1339 /* P-type */ | |
1340 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { | |
1341 /* P_L0_D16x16, P_8x8 */ | |
1342 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); | |
1343 } else { | |
1344 /* P_L0_D8x16, P_L0_D16x8 */ | |
1345 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); | |
1346 } | |
1347 partition_count= p_mb_type_info[mb_type].partition_count; | |
1348 mb_type= p_mb_type_info[mb_type].type; | |
1349 } else { | |
1350 mb_type= decode_cabac_intra_mb_type(h, 17, 0); | |
1351 goto decode_intra_mb; | |
1352 } | |
1353 } else { | |
1354 mb_type= decode_cabac_intra_mb_type(h, 3, 1); | |
1355 if(h->slice_type == FF_SI_TYPE && mb_type) | |
1356 mb_type--; | |
1357 assert(h->slice_type_nos == FF_I_TYPE); | |
1358 decode_intra_mb: | |
1359 partition_count = 0; | |
1360 cbp= i_mb_type_info[mb_type].cbp; | |
1361 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
1362 mb_type= i_mb_type_info[mb_type].type; | |
1363 } | |
1364 if(MB_FIELD) | |
1365 mb_type |= MB_TYPE_INTERLACED; | |
1366 | |
1367 h->slice_table[ mb_xy ]= h->slice_num; | |
1368 | |
1369 if(IS_INTRA_PCM(mb_type)) { | |
1370 const uint8_t *ptr; | |
1371 | |
1372 // We assume these blocks are very rare so we do not optimize it. | |
1373 // FIXME The two following lines get the bitstream position in the cabac | |
1374 // decode, I think it should be done by a function in cabac.h (or cabac.c). | |
1375 ptr= h->cabac.bytestream; | |
1376 if(h->cabac.low&0x1) ptr--; | |
1377 if(CABAC_BITS==16){ | |
1378 if(h->cabac.low&0x1FF) ptr--; | |
1379 } | |
1380 | |
1381 // The pixels are stored in the same order as levels in h->mb array. | |
1382 memcpy(h->mb, ptr, 256); ptr+=256; | |
1383 if(CHROMA){ | |
1384 memcpy(h->mb+128, ptr, 128); ptr+=128; | |
1385 } | |
1386 | |
1387 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); | |
1388 | |
1389 // All blocks are present | |
1390 h->cbp_table[mb_xy] = 0x1ef; | |
1391 h->chroma_pred_mode_table[mb_xy] = 0; | |
1392 // In deblocking, the quantizer is 0 | |
1393 s->current_picture.qscale_table[mb_xy]= 0; | |
1394 // All coeffs are present | |
1395 memset(h->non_zero_count[mb_xy], 16, 16); | |
1396 s->current_picture.mb_type[mb_xy]= mb_type; | |
1397 h->last_qscale_diff = 0; | |
1398 return 0; | |
1399 } | |
1400 | |
1401 if(MB_MBAFF){ | |
1402 h->ref_count[0] <<= 1; | |
1403 h->ref_count[1] <<= 1; | |
1404 } | |
1405 | |
1406 fill_caches(h, mb_type, 0); | |
1407 | |
1408 if( IS_INTRA( mb_type ) ) { | |
1409 int i, pred_mode; | |
1410 if( IS_INTRA4x4( mb_type ) ) { | |
1411 if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) { | |
1412 mb_type |= MB_TYPE_8x8DCT; | |
1413 for( i = 0; i < 16; i+=4 ) { | |
1414 int pred = pred_intra_mode( h, i ); | |
1415 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1416 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
1417 } | |
1418 } else { | |
1419 for( i = 0; i < 16; i++ ) { | |
1420 int pred = pred_intra_mode( h, i ); | |
1421 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1422 | |
1423 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); | |
1424 } | |
1425 } | |
1426 ff_h264_write_back_intra_pred_mode(h); | |
1427 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1; | |
1428 } else { | |
1429 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode ); | |
1430 if( h->intra16x16_pred_mode < 0 ) return -1; | |
1431 } | |
1432 if(CHROMA){ | |
1433 h->chroma_pred_mode_table[mb_xy] = | |
1434 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); | |
1435 | |
1436 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode ); | |
1437 if( pred_mode < 0 ) return -1; | |
1438 h->chroma_pred_mode= pred_mode; | |
1439 } | |
1440 } else if( partition_count == 4 ) { | |
1441 int i, j, sub_partition_count[4], list, ref[2][4]; | |
1442 | |
1443 if( h->slice_type_nos == FF_B_TYPE ) { | |
1444 for( i = 0; i < 4; i++ ) { | |
1445 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); | |
1446 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1447 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1448 } | |
1449 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | | |
1450 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
1451 ff_h264_pred_direct_motion(h, &mb_type); | |
1452 h->ref_cache[0][scan8[4]] = | |
1453 h->ref_cache[1][scan8[4]] = | |
1454 h->ref_cache[0][scan8[12]] = | |
1455 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
1456 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) { | |
1457 for( i = 0; i < 4; i++ ) | |
1458 if( IS_DIRECT(h->sub_mb_type[i]) ) | |
1459 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 ); | |
1460 } | |
1461 } | |
1462 } else { | |
1463 for( i = 0; i < 4; i++ ) { | |
1464 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); | |
1465 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1466 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1467 } | |
1468 } | |
1469 | |
1470 for( list = 0; list < h->list_count; list++ ) { | |
1471 for( i = 0; i < 4; i++ ) { | |
1472 if(IS_DIRECT(h->sub_mb_type[i])) continue; | |
1473 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1474 if( h->ref_count[list] > 1 ){ | |
1475 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); | |
1476 if(ref[list][i] >= (unsigned)h->ref_count[list]){ | |
1477 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]); | |
1478 return -1; | |
1479 } | |
1480 }else | |
1481 ref[list][i] = 0; | |
1482 } else { | |
1483 ref[list][i] = -1; | |
1484 } | |
1485 h->ref_cache[list][ scan8[4*i]+1 ]= | |
1486 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
1487 } | |
1488 } | |
1489 | |
1490 if(dct8x8_allowed) | |
1491 dct8x8_allowed = get_dct8x8_allowed(h); | |
1492 | |
1493 for(list=0; list<h->list_count; list++){ | |
1494 for(i=0; i<4; i++){ | |
1495 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; | |
1496 if(IS_DIRECT(h->sub_mb_type[i])){ | |
1497 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4); | |
1498 continue; | |
1499 } | |
1500 | |
1501 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ | |
1502 const int sub_mb_type= h->sub_mb_type[i]; | |
1503 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
1504 for(j=0; j<sub_partition_count[i]; j++){ | |
1505 int mpx, mpy; | |
1506 int mx, my; | |
1507 const int index= 4*i + block_width*j; | |
1508 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
1509 int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; | |
1510 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy); | |
1511 | |
1512 mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 ); | |
1513 my = mpy + decode_cabac_mb_mvd( h, list, index, 1 ); | |
1514 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
1515 | |
1516 if(IS_SUB_8X8(sub_mb_type)){ | |
1517 mv_cache[ 1 ][0]= | |
1518 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
1519 mv_cache[ 1 ][1]= | |
1520 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
1521 | |
1522 mvd_cache[ 1 ][0]= | |
1523 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx; | |
1524 mvd_cache[ 1 ][1]= | |
1525 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy; | |
1526 }else if(IS_SUB_8X4(sub_mb_type)){ | |
1527 mv_cache[ 1 ][0]= mx; | |
1528 mv_cache[ 1 ][1]= my; | |
1529 | |
1530 mvd_cache[ 1 ][0]= mx - mpx; | |
1531 mvd_cache[ 1 ][1]= my - mpy; | |
1532 }else if(IS_SUB_4X8(sub_mb_type)){ | |
1533 mv_cache[ 8 ][0]= mx; | |
1534 mv_cache[ 8 ][1]= my; | |
1535 | |
1536 mvd_cache[ 8 ][0]= mx - mpx; | |
1537 mvd_cache[ 8 ][1]= my - mpy; | |
1538 } | |
1539 mv_cache[ 0 ][0]= mx; | |
1540 mv_cache[ 0 ][1]= my; | |
1541 | |
1542 mvd_cache[ 0 ][0]= mx - mpx; | |
1543 mvd_cache[ 0 ][1]= my - mpy; | |
1544 } | |
1545 }else{ | |
1546 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; | |
1547 uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0]; | |
1548 p[0] = p[1] = p[8] = p[9] = 0; | |
1549 pd[0]= pd[1]= pd[8]= pd[9]= 0; | |
1550 } | |
1551 } | |
1552 } | |
1553 } else if( IS_DIRECT(mb_type) ) { | |
1554 ff_h264_pred_direct_motion(h, &mb_type); | |
1555 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4); | |
1556 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4); | |
1557 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; | |
1558 } else { | |
1559 int list, mx, my, i, mpx, mpy; | |
1560 if(IS_16X16(mb_type)){ | |
1561 for(list=0; list<h->list_count; list++){ | |
1562 if(IS_DIR(mb_type, 0, list)){ | |
1563 int ref; | |
1564 if(h->ref_count[list] > 1){ | |
1565 ref= decode_cabac_mb_ref(h, list, 0); | |
1566 if(ref >= (unsigned)h->ref_count[list]){ | |
1567 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1568 return -1; | |
1569 } | |
1570 }else | |
1571 ref=0; | |
1572 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); | |
1573 }else | |
1574 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 | |
1575 } | |
1576 for(list=0; list<h->list_count; list++){ | |
1577 if(IS_DIR(mb_type, 0, list)){ | |
1578 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy); | |
1579 | |
1580 mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 ); | |
1581 my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 ); | |
1582 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
1583 | |
1584 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4); | |
1585 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); | |
1586 }else | |
1587 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1588 } | |
1589 } | |
1590 else if(IS_16X8(mb_type)){ | |
1591 for(list=0; list<h->list_count; list++){ | |
1592 for(i=0; i<2; i++){ | |
1593 if(IS_DIR(mb_type, i, list)){ | |
1594 int ref; | |
1595 if(h->ref_count[list] > 1){ | |
1596 ref= decode_cabac_mb_ref( h, list, 8*i ); | |
1597 if(ref >= (unsigned)h->ref_count[list]){ | |
1598 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1599 return -1; | |
1600 } | |
1601 }else | |
1602 ref=0; | |
1603 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); | |
1604 }else | |
1605 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1606 } | |
1607 } | |
1608 for(list=0; list<h->list_count; list++){ | |
1609 for(i=0; i<2; i++){ | |
1610 if(IS_DIR(mb_type, i, list)){ | |
1611 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy); | |
1612 mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 ); | |
1613 my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 ); | |
1614 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
1615 | |
1616 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4); | |
1617 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); | |
1618 }else{ | |
1619 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1620 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); | |
1621 } | |
1622 } | |
1623 } | |
1624 }else{ | |
1625 assert(IS_8X16(mb_type)); | |
1626 for(list=0; list<h->list_count; list++){ | |
1627 for(i=0; i<2; i++){ | |
1628 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
1629 int ref; | |
1630 if(h->ref_count[list] > 1){ | |
1631 ref= decode_cabac_mb_ref( h, list, 4*i ); | |
1632 if(ref >= (unsigned)h->ref_count[list]){ | |
1633 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1634 return -1; | |
1635 } | |
1636 }else | |
1637 ref=0; | |
1638 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); | |
1639 }else | |
1640 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1641 } | |
1642 } | |
1643 for(list=0; list<h->list_count; list++){ | |
1644 for(i=0; i<2; i++){ | |
1645 if(IS_DIR(mb_type, i, list)){ | |
1646 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy); | |
1647 mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 ); | |
1648 my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 ); | |
1649 | |
1650 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
1651 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4); | |
1652 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); | |
1653 }else{ | |
1654 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1655 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); | |
1656 } | |
1657 } | |
1658 } | |
1659 } | |
1660 } | |
1661 | |
1662 if( IS_INTER( mb_type ) ) { | |
1663 h->chroma_pred_mode_table[mb_xy] = 0; | |
1664 write_back_motion( h, mb_type ); | |
1665 } | |
1666 | |
1667 if( !IS_INTRA16x16( mb_type ) ) { | |
1668 cbp = decode_cabac_mb_cbp_luma( h ); | |
1669 if(CHROMA) | |
1670 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; | |
1671 } | |
1672 | |
1673 h->cbp_table[mb_xy] = h->cbp = cbp; | |
1674 | |
1675 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { | |
1676 if( decode_cabac_mb_transform_size( h ) ) | |
1677 mb_type |= MB_TYPE_8x8DCT; | |
1678 } | |
1679 s->current_picture.mb_type[mb_xy]= mb_type; | |
1680 | |
1681 if( cbp || IS_INTRA16x16( mb_type ) ) { | |
1682 const uint8_t *scan, *scan8x8, *dc_scan; | |
1683 const uint32_t *qmul; | |
1684 int dqp; | |
1685 | |
1686 if(IS_INTERLACED(mb_type)){ | |
1687 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; | |
1688 scan= s->qscale ? h->field_scan : h->field_scan_q0; | |
1689 dc_scan= luma_dc_field_scan; | |
1690 }else{ | |
1691 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; | |
1692 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; | |
1693 dc_scan= luma_dc_zigzag_scan; | |
1694 } | |
1695 | |
1696 h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h ); | |
1697 if( dqp == INT_MIN ){ | |
1698 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y); | |
1699 return -1; | |
1700 } | |
1701 s->qscale += dqp; | |
1702 if(((unsigned)s->qscale) > 51){ | |
1703 if(s->qscale<0) s->qscale+= 52; | |
1704 else s->qscale-= 52; | |
1705 } | |
1706 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); | |
1707 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); | |
1708 | |
1709 if( IS_INTRA16x16( mb_type ) ) { | |
1710 int i; | |
1711 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); | |
1712 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16); | |
1713 | |
1714 if( cbp&15 ) { | |
1715 qmul = h->dequant4_coeff[0][s->qscale]; | |
1716 for( i = 0; i < 16; i++ ) { | |
1717 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); | |
1718 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); | |
1719 } | |
1720 } else { | |
1721 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1722 } | |
1723 } else { | |
1724 int i8x8, i4x4; | |
1725 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { | |
1726 if( cbp & (1<<i8x8) ) { | |
1727 if( IS_8x8DCT(mb_type) ) { | |
1728 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
1729 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); | |
1730 } else { | |
1731 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; | |
1732 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { | |
1733 const int index = 4*i8x8 + i4x4; | |
1734 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); | |
1735 //START_TIMER | |
1736 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16); | |
1737 //STOP_TIMER("decode_residual") | |
1738 } | |
1739 } | |
1740 } else { | |
1741 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
1742 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
1743 } | |
1744 } | |
1745 } | |
1746 | |
1747 if( cbp&0x30 ){ | |
1748 int c; | |
1749 for( c = 0; c < 2; c++ ) { | |
1750 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); | |
1751 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4); | |
1752 } | |
1753 } | |
1754 | |
1755 if( cbp&0x20 ) { | |
1756 int c, i; | |
1757 for( c = 0; c < 2; c++ ) { | |
1758 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; | |
1759 for( i = 0; i < 4; i++ ) { | |
1760 const int index = 16 + 4 * c + i; | |
1761 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); | |
1762 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); | |
1763 } | |
1764 } | |
1765 } else { | |
1766 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
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 } | |
1770 } else { | |
1771 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1772 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
1773 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1774 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1775 h->last_qscale_diff = 0; | |
1776 } | |
1777 | |
1778 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1779 write_back_non_zero_count(h); | |
1780 | |
1781 if(MB_MBAFF){ | |
1782 h->ref_count[0] >>= 1; | |
1783 h->ref_count[1] >>= 1; | |
1784 } | |
1785 | |
1786 return 0; | |
1787 } |