Mercurial > libavcodec.hg
annotate h264_cabac.c @ 12266:48d6738904a9 libavcodec
Fix SPLATB_REG mess. Used to be a if/elseif/elseif/elseif spaghetti, so this
splits it into small optimization-specific macros which are selected for each
DSP function. The advantage of this approach is that the sse4 functions now
use the ssse3 codepath also without needing an explicit sse4 codepath.
author | rbultje |
---|---|
date | Sat, 24 Jul 2010 19:33:05 +0000 |
parents | 7dd2a45249a9 |
children |
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 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11556
diff
changeset
|
23 * @file |
10869 | 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; | |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
691 const int8_t (*tab)[2]; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
692 |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
693 if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
694 else tab = cabac_context_init_PB[h->cabac_init_idc]; |
10869 | 695 |
696 /* calculate pre-state */ | |
697 for( i= 0; i < 460; i++ ) { | |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
698 int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127; |
10869 | 699 |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
700 pre^= pre>>31; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
701 if(pre > 124) |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
702 pre= 124 + (pre&1); |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
703 |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
704 h->cabac_state[i] = pre; |
10869 | 705 } |
706 } | |
707 | |
708 static int decode_cabac_field_decoding_flag(H264Context *h) { | |
709 MpegEncContext * const s = &h->s; | |
11004 | 710 const long mbb_xy = h->mb_xy - 2L*s->mb_stride; |
10869 | 711 |
11004 | 712 unsigned long ctx = 0; |
10869 | 713 |
11201
4e2d74d7bad8
Speedup decode_cabac_field_decoding_flag() by 9 cpu cycles.
michael
parents:
11191
diff
changeset
|
714 ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num); |
11004 | 715 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num); |
10869 | 716 |
11004 | 717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] ); |
10869 | 718 } |
719 | |
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]; | |
722 int mb_type; | |
723 | |
724 if(intra_slice){ | |
725 int ctx=0; | |
11186
90de754f70d6
2 cpu cycles faster context calculation for decode_cabac_intra_mb_type()
michael
parents:
11185
diff
changeset
|
726 if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) |
10869 | 727 ctx++; |
11186
90de754f70d6
2 cpu cycles faster context calculation for decode_cabac_intra_mb_type()
michael
parents:
11185
diff
changeset
|
728 if( h->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) |
10869 | 729 ctx++; |
730 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) | |
731 return 0; /* I4x4 */ | |
732 state += 2; | |
733 }else{ | |
10930 | 734 if( get_cabac_noinline( &h->cabac, state ) == 0 ) |
10869 | 735 return 0; /* I4x4 */ |
736 } | |
737 | |
738 if( get_cabac_terminate( &h->cabac ) ) | |
739 return 25; /* PCM */ | |
740 | |
741 mb_type = 1; /* I16x16 */ | |
742 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */ | |
743 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */ | |
744 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] ); | |
745 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] ); | |
746 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); | |
747 return mb_type; | |
748 } | |
749 | |
750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) { | |
751 MpegEncContext * const s = &h->s; | |
752 int mba_xy, mbb_xy; | |
753 int ctx = 0; | |
754 | |
755 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? | |
756 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
757 mba_xy = mb_xy - 1; | |
758 if( (mb_y&1) | |
759 && h->slice_table[mba_xy] == h->slice_num | |
760 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
761 mba_xy += s->mb_stride; | |
762 if( MB_FIELD ){ | |
763 mbb_xy = mb_xy - s->mb_stride; | |
764 if( !(mb_y&1) | |
765 && h->slice_table[mbb_xy] == h->slice_num | |
766 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
767 mbb_xy -= s->mb_stride; | |
768 }else | |
769 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
770 }else{ | |
771 int mb_xy = h->mb_xy; | |
772 mba_xy = mb_xy - 1; | |
773 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE); | |
774 } | |
775 | |
776 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )) | |
777 ctx++; | |
778 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )) | |
779 ctx++; | |
780 | |
781 if( h->slice_type_nos == FF_B_TYPE ) | |
782 ctx += 13; | |
783 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] ); | |
784 } | |
785 | |
786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) { | |
787 int mode = 0; | |
788 | |
789 if( get_cabac( &h->cabac, &h->cabac_state[68] ) ) | |
790 return pred_mode; | |
791 | |
792 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
793 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
794 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
795 | |
11182 | 796 return mode + ( mode >= pred_mode ); |
10869 | 797 } |
798 | |
799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { | |
800 const int mba_xy = h->left_mb_xy[0]; | |
801 const int mbb_xy = h->top_mb_xy; | |
802 | |
803 int ctx = 0; | |
804 | |
805 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ | |
11185 | 806 if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 ) |
10869 | 807 ctx++; |
808 | |
11185 | 809 if( h->top_type && h->chroma_pred_mode_table[mbb_xy] != 0 ) |
10869 | 810 ctx++; |
811 | |
812 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) | |
813 return 0; | |
814 | |
815 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
816 return 1; | |
817 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
818 return 2; | |
819 else | |
820 return 3; | |
821 } | |
822 | |
823 static int decode_cabac_mb_cbp_luma( H264Context *h) { | |
824 int cbp_b, cbp_a, ctx, cbp = 0; | |
825 | |
11166
5bd834bd759b
Remove slice_table checks from decode_cabac_mb_cbp_luma() and set left/top_cbp so
michael
parents:
11004
diff
changeset
|
826 cbp_a = h->left_cbp; |
5bd834bd759b
Remove slice_table checks from decode_cabac_mb_cbp_luma() and set left/top_cbp so
michael
parents:
11004
diff
changeset
|
827 cbp_b = h->top_cbp; |
10869 | 828 |
829 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04); | |
11544 | 830 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]); |
10869 | 831 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08); |
11544 | 832 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1; |
10869 | 833 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01); |
11544 | 834 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2; |
10869 | 835 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02); |
11544 | 836 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3; |
10869 | 837 return cbp; |
838 } | |
839 static int decode_cabac_mb_cbp_chroma( H264Context *h) { | |
840 int ctx; | |
841 int cbp_a, cbp_b; | |
842 | |
843 cbp_a = (h->left_cbp>>4)&0x03; | |
844 cbp_b = (h-> top_cbp>>4)&0x03; | |
845 | |
846 ctx = 0; | |
847 if( cbp_a > 0 ) ctx++; | |
848 if( cbp_b > 0 ) ctx += 2; | |
849 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 ) | |
850 return 0; | |
851 | |
852 ctx = 4; | |
853 if( cbp_a == 2 ) ctx++; | |
854 if( cbp_b == 2 ) ctx += 2; | |
855 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ); | |
856 } | |
857 | |
858 static int decode_cabac_p_mb_sub_type( H264Context *h ) { | |
859 if( get_cabac( &h->cabac, &h->cabac_state[21] ) ) | |
860 return 0; /* 8x8 */ | |
861 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) ) | |
862 return 1; /* 8x4 */ | |
863 if( get_cabac( &h->cabac, &h->cabac_state[23] ) ) | |
864 return 2; /* 4x8 */ | |
865 return 3; /* 4x4 */ | |
866 } | |
867 static int decode_cabac_b_mb_sub_type( H264Context *h ) { | |
868 int type; | |
869 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) ) | |
870 return 0; /* B_Direct_8x8 */ | |
871 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) ) | |
872 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */ | |
873 type = 3; | |
874 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) { | |
875 if( get_cabac( &h->cabac, &h->cabac_state[39] ) ) | |
876 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */ | |
877 type += 4; | |
878 } | |
879 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] ); | |
880 type += get_cabac( &h->cabac, &h->cabac_state[39] ); | |
881 return type; | |
882 } | |
883 | |
884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) { | |
885 int refa = h->ref_cache[list][scan8[n] - 1]; | |
886 int refb = h->ref_cache[list][scan8[n] - 8]; | |
887 int ref = 0; | |
888 int ctx = 0; | |
889 | |
890 if( h->slice_type_nos == FF_B_TYPE) { | |
11167 | 891 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) ) |
10869 | 892 ctx++; |
11167 | 893 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) ) |
10869 | 894 ctx += 2; |
895 } else { | |
896 if( refa > 0 ) | |
897 ctx++; | |
898 if( refb > 0 ) | |
899 ctx += 2; | |
900 } | |
901 | |
902 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) { | |
903 ref++; | |
904 ctx = (ctx>>2)+4; | |
905 if(ref >= 32 /*h->ref_list[list]*/){ | |
906 return -1; | |
907 } | |
908 } | |
909 return ref; | |
910 } | |
911 | |
11275 | 912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) { |
10869 | 913 int mvd; |
914 | |
11305
1a349d669184
Optimize (amvd>2)+(amvd>32), about 1 cpu cycles faster.
michael
parents:
11277
diff
changeset
|
915 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){ |
1a349d669184
Optimize (amvd>2)+(amvd>32), about 1 cpu cycles faster.
michael
parents:
11277
diff
changeset
|
916 // if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){ |
11275 | 917 *mvda= 0; |
10869 | 918 return 0; |
11275 | 919 } |
10869 | 920 |
921 mvd= 1; | |
11207
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
922 ctxbase+= 3; |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
923 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) { |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
924 if( mvd < 4 ) |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
925 ctxbase++; |
10869 | 926 mvd++; |
927 } | |
928 | |
929 if( mvd >= 9 ) { | |
930 int k = 3; | |
931 while( get_cabac_bypass( &h->cabac ) ) { | |
932 mvd += 1 << k; | |
933 k++; | |
934 if(k>24){ | |
935 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); | |
936 return INT_MIN; | |
937 } | |
938 } | |
939 while( k-- ) { | |
11208 | 940 mvd += get_cabac_bypass( &h->cabac )<<k; |
10869 | 941 } |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
942 *mvda=mvd < 70 ? mvd : 70; |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
943 }else |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
944 *mvda=mvd; |
10869 | 945 return get_cabac_bypass_sign( &h->cabac, -mvd ); |
946 } | |
947 | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
948 #define DECODE_CABAC_MB_MVD( h, list, n )\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
949 {\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
950 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
951 h->mvd_cache[list][scan8[n] - 8][0];\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
952 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
953 h->mvd_cache[list][scan8[n] - 8][1];\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
954 \ |
11275 | 955 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\ |
956 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\ | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
957 } |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
958 |
10869 | 959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) { |
960 int nza, nzb; | |
961 int ctx = 0; | |
962 | |
963 if( is_dc ) { | |
964 if( cat == 0 ) { | |
965 nza = h->left_cbp&0x100; | |
966 nzb = h-> top_cbp&0x100; | |
967 } else { | |
968 nza = (h->left_cbp>>(6+idx))&0x01; | |
969 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
970 } | |
971 } else { | |
972 assert(cat == 1 || cat == 2 || cat == 4); | |
973 nza = h->non_zero_count_cache[scan8[idx] - 1]; | |
974 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
975 } | |
976 | |
977 if( nza > 0 ) | |
978 ctx++; | |
979 | |
980 if( nzb > 0 ) | |
981 ctx += 2; | |
982 | |
983 return ctx + 4 * cat; | |
984 } | |
985 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10930
diff
changeset
|
986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = { |
10869 | 987 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
988 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
989 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
990 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
991 }; | |
992 | |
993 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 ) { | |
994 static const int significant_coeff_flag_offset[2][6] = { | |
995 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
996 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
997 }; | |
998 static const int last_coeff_flag_offset[2][6] = { | |
999 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
1000 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
1001 }; | |
1002 static const int coeff_abs_level_m1_offset[6] = { | |
1003 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
1004 }; | |
1005 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { | |
1006 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, | |
1007 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, | |
1008 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
1009 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, | |
1010 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
1011 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
1012 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
1013 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
1014 }; | |
1015 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0). | |
1016 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter). | |
1017 * map node ctx => cabac ctx for level=1 */ | |
1018 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 }; | |
1019 /* map node ctx => cabac ctx for level>1 */ | |
1020 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 }; | |
1021 static const uint8_t coeff_abs_level_transition[2][8] = { | |
1022 /* update node ctx after decoding a level=1 */ | |
1023 { 1, 2, 3, 3, 4, 5, 6, 7 }, | |
1024 /* update node ctx after decoding a level>1 */ | |
1025 { 4, 4, 4, 4, 5, 6, 7, 7 } | |
1026 }; | |
1027 | |
1028 int index[64]; | |
1029 | |
1030 int av_unused last; | |
1031 int coeff_count = 0; | |
1032 int node_ctx = 0; | |
1033 | |
1034 uint8_t *significant_coeff_ctx_base; | |
1035 uint8_t *last_coeff_ctx_base; | |
1036 uint8_t *abs_level_m1_ctx_base; | |
1037 | |
1038 #if !ARCH_X86 | |
1039 #define CABAC_ON_STACK | |
1040 #endif | |
1041 #ifdef CABAC_ON_STACK | |
1042 #define CC &cc | |
1043 CABACContext cc; | |
1044 cc.range = h->cabac.range; | |
1045 cc.low = h->cabac.low; | |
1046 cc.bytestream= h->cabac.bytestream; | |
1047 #else | |
1048 #define CC &h->cabac | |
1049 #endif | |
1050 | |
1051 | |
1052 /* cat: 0-> DC 16x16 n = 0 | |
1053 * 1-> AC 16x16 n = luma4x4idx | |
1054 * 2-> Luma4x4 n = luma4x4idx | |
1055 * 3-> DC Chroma n = iCbCr | |
1056 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx | |
1057 * 5-> Luma8x8 n = 4 * luma8x8idx | |
1058 */ | |
1059 | |
1060 /* read coded block flag */ | |
1061 if( is_dc || cat != 5 ) { | |
1062 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) { | |
1063 if( !is_dc ) | |
1064 h->non_zero_count_cache[scan8[n]] = 0; | |
1065 | |
1066 #ifdef CABAC_ON_STACK | |
1067 h->cabac.range = cc.range ; | |
1068 h->cabac.low = cc.low ; | |
1069 h->cabac.bytestream= cc.bytestream; | |
1070 #endif | |
1071 return; | |
1072 } | |
1073 } | |
1074 | |
1075 significant_coeff_ctx_base = h->cabac_state | |
1076 + significant_coeff_flag_offset[MB_FIELD][cat]; | |
1077 last_coeff_ctx_base = h->cabac_state | |
1078 + last_coeff_flag_offset[MB_FIELD][cat]; | |
1079 abs_level_m1_ctx_base = h->cabac_state | |
1080 + coeff_abs_level_m1_offset[cat]; | |
1081 | |
1082 if( !is_dc && cat == 5 ) { | |
1083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
1084 for(last= 0; last < coefs; last++) { \ | |
1085 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \ | |
1086 if( get_cabac( CC, sig_ctx )) { \ | |
1087 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ | |
1088 index[coeff_count++] = last; \ | |
1089 if( get_cabac( CC, last_ctx ) ) { \ | |
1090 last= max_coeff; \ | |
1091 break; \ | |
1092 } \ | |
1093 } \ | |
1094 }\ | |
1095 if( last == max_coeff -1 ) {\ | |
1096 index[coeff_count++] = last;\ | |
1097 } | |
1098 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; | |
1099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) | |
1100 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); | |
1101 } else { | |
1102 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
1103 #else | |
1104 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); | |
1105 } else { | |
1106 DECODE_SIGNIFICANCE( max_coeff - 1, last, last ); | |
1107 #endif | |
1108 } | |
1109 assert(coeff_count > 0); | |
1110 | |
1111 if( is_dc ) { | |
1112 if( cat == 0 ) | |
1113 h->cbp_table[h->mb_xy] |= 0x100; | |
1114 else | |
1115 h->cbp_table[h->mb_xy] |= 0x40 << n; | |
1116 } else { | |
1117 if( cat == 5 ) | |
1118 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); | |
1119 else { | |
1120 assert( cat == 1 || cat == 2 || cat == 4 ); | |
1121 h->non_zero_count_cache[scan8[n]] = coeff_count; | |
1122 } | |
1123 } | |
1124 | |
1125 do { | |
1126 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1127 | |
1128 int j= scantable[index[--coeff_count]]; | |
1129 | |
1130 if( get_cabac( CC, ctx ) == 0 ) { | |
1131 node_ctx = coeff_abs_level_transition[0][node_ctx]; | |
1132 if( is_dc ) { | |
1133 block[j] = get_cabac_bypass_sign( CC, -1); | |
1134 }else{ | |
1135 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; | |
1136 } | |
1137 } else { | |
1138 int coeff_abs = 2; | |
1139 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1140 node_ctx = coeff_abs_level_transition[1][node_ctx]; | |
1141 | |
1142 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { | |
1143 coeff_abs++; | |
1144 } | |
1145 | |
1146 if( coeff_abs >= 15 ) { | |
1147 int j = 0; | |
1148 while( get_cabac_bypass( CC ) ) { | |
1149 j++; | |
1150 } | |
1151 | |
1152 coeff_abs=1; | |
1153 while( j-- ) { | |
1154 coeff_abs += coeff_abs + get_cabac_bypass( CC ); | |
1155 } | |
1156 coeff_abs+= 14; | |
1157 } | |
1158 | |
1159 if( is_dc ) { | |
1160 block[j] = get_cabac_bypass_sign( CC, -coeff_abs ); | |
1161 }else{ | |
1162 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6; | |
1163 } | |
1164 } | |
1165 } while( coeff_count ); | |
1166 #ifdef CABAC_ON_STACK | |
1167 h->cabac.range = cc.range ; | |
1168 h->cabac.low = cc.low ; | |
1169 h->cabac.bytestream= cc.bytestream; | |
1170 #endif | |
1171 | |
1172 } | |
1173 | |
11542 | 1174 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) { |
1175 decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1); | |
10869 | 1176 } |
1177 | |
1178 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 ) { | |
1179 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0); | |
1180 } | |
1181 | |
1182 /** | |
1183 * decodes a macroblock | |
11556 | 1184 * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed |
10869 | 1185 */ |
1186 int ff_h264_decode_mb_cabac(H264Context *h) { | |
1187 MpegEncContext * const s = &h->s; | |
1188 int mb_xy; | |
1189 int mb_type, partition_count, cbp = 0; | |
1190 int dct8x8_allowed= h->pps.transform_8x8_mode; | |
1191 | |
1192 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1193 | |
1194 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); | |
1195 if( h->slice_type_nos != FF_I_TYPE ) { | |
1196 int skip; | |
1197 /* a skipped mb needs the aff flag from the following mb */ | |
1198 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
1199 skip = h->next_mb_skipped; | |
1200 else | |
1201 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1202 /* read skip flags */ | |
1203 if( skip ) { | |
1204 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
1205 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
1206 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
1207 if(!h->next_mb_skipped) | |
1208 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1209 } | |
1210 | |
1211 decode_mb_skip(h); | |
1212 | |
1213 h->cbp_table[mb_xy] = 0; | |
1214 h->chroma_pred_mode_table[mb_xy] = 0; | |
1215 h->last_qscale_diff = 0; | |
1216 | |
1217 return 0; | |
1218 | |
1219 } | |
1220 } | |
1221 if(FRAME_MBAFF){ | |
1222 if( (s->mb_y&1) == 0 ) | |
1223 h->mb_mbaff = | |
1224 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1225 } | |
1226 | |
1227 h->prev_mb_skipped = 0; | |
1228 | |
11184
cc70f8c44019
Drop compute_mb_neighbors() and move fill_decode_neighbors() up to take its
michael
parents:
11183
diff
changeset
|
1229 fill_decode_neighbors(h, -(MB_FIELD)); |
10869 | 1230 |
1231 if( h->slice_type_nos == FF_B_TYPE ) { | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1232 int ctx = 0; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1233 assert(h->slice_type_nos == FF_B_TYPE); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1234 |
11185 | 1235 if( !IS_DIRECT( h->left_type[0]-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1236 ctx++; |
11185 | 1237 if( !IS_DIRECT( h->top_type-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1238 ctx++; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1239 |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1240 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1241 mb_type= 0; /* B_Direct_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1242 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) { |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1243 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1244 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1245 int bits; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1246 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3; |
11544 | 1247 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2; |
1248 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1; | |
1249 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1250 if( bits < 8 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1251 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1252 }else if( bits == 13 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1253 mb_type= decode_cabac_intra_mb_type(h, 32, 0); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1254 goto decode_intra_mb; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1255 }else if( bits == 14 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1256 mb_type= 11; /* B_L1_L0_8x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1257 }else if( bits == 15 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1258 mb_type= 22; /* B_8x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1259 }else{ |
11544 | 1260 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1261 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1262 } |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1263 } |
10869 | 1264 partition_count= b_mb_type_info[mb_type].partition_count; |
1265 mb_type= b_mb_type_info[mb_type].type; | |
1266 } else if( h->slice_type_nos == FF_P_TYPE ) { | |
1267 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { | |
1268 /* P-type */ | |
1269 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { | |
1270 /* P_L0_D16x16, P_8x8 */ | |
1271 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); | |
1272 } else { | |
1273 /* P_L0_D8x16, P_L0_D16x8 */ | |
1274 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); | |
1275 } | |
1276 partition_count= p_mb_type_info[mb_type].partition_count; | |
1277 mb_type= p_mb_type_info[mb_type].type; | |
1278 } else { | |
1279 mb_type= decode_cabac_intra_mb_type(h, 17, 0); | |
1280 goto decode_intra_mb; | |
1281 } | |
1282 } else { | |
1283 mb_type= decode_cabac_intra_mb_type(h, 3, 1); | |
1284 if(h->slice_type == FF_SI_TYPE && mb_type) | |
1285 mb_type--; | |
1286 assert(h->slice_type_nos == FF_I_TYPE); | |
1287 decode_intra_mb: | |
1288 partition_count = 0; | |
1289 cbp= i_mb_type_info[mb_type].cbp; | |
1290 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
1291 mb_type= i_mb_type_info[mb_type].type; | |
1292 } | |
1293 if(MB_FIELD) | |
1294 mb_type |= MB_TYPE_INTERLACED; | |
1295 | |
1296 h->slice_table[ mb_xy ]= h->slice_num; | |
1297 | |
1298 if(IS_INTRA_PCM(mb_type)) { | |
1299 const uint8_t *ptr; | |
1300 | |
1301 // We assume these blocks are very rare so we do not optimize it. | |
1302 // FIXME The two following lines get the bitstream position in the cabac | |
1303 // decode, I think it should be done by a function in cabac.h (or cabac.c). | |
1304 ptr= h->cabac.bytestream; | |
1305 if(h->cabac.low&0x1) ptr--; | |
1306 if(CABAC_BITS==16){ | |
1307 if(h->cabac.low&0x1FF) ptr--; | |
1308 } | |
1309 | |
1310 // The pixels are stored in the same order as levels in h->mb array. | |
1311 memcpy(h->mb, ptr, 256); ptr+=256; | |
1312 if(CHROMA){ | |
1313 memcpy(h->mb+128, ptr, 128); ptr+=128; | |
1314 } | |
1315 | |
1316 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); | |
1317 | |
1318 // All blocks are present | |
1319 h->cbp_table[mb_xy] = 0x1ef; | |
1320 h->chroma_pred_mode_table[mb_xy] = 0; | |
1321 // In deblocking, the quantizer is 0 | |
1322 s->current_picture.qscale_table[mb_xy]= 0; | |
1323 // All coeffs are present | |
10906 | 1324 memset(h->non_zero_count[mb_xy], 16, 32); |
10869 | 1325 s->current_picture.mb_type[mb_xy]= mb_type; |
1326 h->last_qscale_diff = 0; | |
1327 return 0; | |
1328 } | |
1329 | |
1330 if(MB_MBAFF){ | |
1331 h->ref_count[0] <<= 1; | |
1332 h->ref_count[1] <<= 1; | |
1333 } | |
1334 | |
10907 | 1335 fill_decode_caches(h, mb_type); |
10869 | 1336 |
1337 if( IS_INTRA( mb_type ) ) { | |
1338 int i, pred_mode; | |
1339 if( IS_INTRA4x4( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1340 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) { |
10869 | 1341 mb_type |= MB_TYPE_8x8DCT; |
1342 for( i = 0; i < 16; i+=4 ) { | |
1343 int pred = pred_intra_mode( h, i ); | |
1344 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1345 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
1346 } | |
1347 } else { | |
1348 for( i = 0; i < 16; i++ ) { | |
1349 int pred = pred_intra_mode( h, i ); | |
1350 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1351 | |
1352 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); | |
1353 } | |
1354 } | |
1355 ff_h264_write_back_intra_pred_mode(h); | |
1356 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1; | |
1357 } else { | |
1358 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode ); | |
1359 if( h->intra16x16_pred_mode < 0 ) return -1; | |
1360 } | |
1361 if(CHROMA){ | |
1362 h->chroma_pred_mode_table[mb_xy] = | |
1363 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); | |
1364 | |
1365 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode ); | |
1366 if( pred_mode < 0 ) return -1; | |
1367 h->chroma_pred_mode= pred_mode; | |
1368 } | |
1369 } else if( partition_count == 4 ) { | |
1370 int i, j, sub_partition_count[4], list, ref[2][4]; | |
1371 | |
1372 if( h->slice_type_nos == FF_B_TYPE ) { | |
1373 for( i = 0; i < 4; i++ ) { | |
1374 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); | |
1375 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1376 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1377 } | |
1378 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | | |
1379 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
1380 ff_h264_pred_direct_motion(h, &mb_type); | |
1381 h->ref_cache[0][scan8[4]] = | |
1382 h->ref_cache[1][scan8[4]] = | |
1383 h->ref_cache[0][scan8[12]] = | |
1384 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
1385 for( i = 0; i < 4; i++ ) | |
11168
a820571a6712
Set sub_mb_type in direct_cache instead of just the direct flag.
michael
parents:
11167
diff
changeset
|
1386 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 ); |
10869 | 1387 } |
1388 } else { | |
1389 for( i = 0; i < 4; i++ ) { | |
1390 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); | |
1391 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1392 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1393 } | |
1394 } | |
1395 | |
1396 for( list = 0; list < h->list_count; list++ ) { | |
1397 for( i = 0; i < 4; i++ ) { | |
1398 if(IS_DIRECT(h->sub_mb_type[i])) continue; | |
1399 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1400 if( h->ref_count[list] > 1 ){ | |
1401 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); | |
1402 if(ref[list][i] >= (unsigned)h->ref_count[list]){ | |
1403 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]); | |
1404 return -1; | |
1405 } | |
1406 }else | |
1407 ref[list][i] = 0; | |
1408 } else { | |
1409 ref[list][i] = -1; | |
1410 } | |
1411 h->ref_cache[list][ scan8[4*i]+1 ]= | |
1412 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
1413 } | |
1414 } | |
1415 | |
1416 if(dct8x8_allowed) | |
1417 dct8x8_allowed = get_dct8x8_allowed(h); | |
1418 | |
1419 for(list=0; list<h->list_count; list++){ | |
1420 for(i=0; i<4; i++){ | |
1421 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; | |
1422 if(IS_DIRECT(h->sub_mb_type[i])){ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1423 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2); |
10869 | 1424 continue; |
1425 } | |
1426 | |
1427 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ | |
1428 const int sub_mb_type= h->sub_mb_type[i]; | |
1429 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
1430 for(j=0; j<sub_partition_count[i]; j++){ | |
1431 int mpx, mpy; | |
1432 int mx, my; | |
1433 const int index= 4*i + block_width*j; | |
1434 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1435 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
11275 | 1436 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1437 DECODE_CABAC_MB_MVD( h, list, index) |
10869 | 1438 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1439 | |
1440 if(IS_SUB_8X8(sub_mb_type)){ | |
1441 mv_cache[ 1 ][0]= | |
1442 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
1443 mv_cache[ 1 ][1]= | |
1444 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
1445 | |
1446 mvd_cache[ 1 ][0]= | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1447 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx; |
10869 | 1448 mvd_cache[ 1 ][1]= |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1449 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy; |
10869 | 1450 }else if(IS_SUB_8X4(sub_mb_type)){ |
1451 mv_cache[ 1 ][0]= mx; | |
1452 mv_cache[ 1 ][1]= my; | |
1453 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1454 mvd_cache[ 1 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1455 mvd_cache[ 1 ][1]= mpy; |
10869 | 1456 }else if(IS_SUB_4X8(sub_mb_type)){ |
1457 mv_cache[ 8 ][0]= mx; | |
1458 mv_cache[ 8 ][1]= my; | |
1459 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1460 mvd_cache[ 8 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1461 mvd_cache[ 8 ][1]= mpy; |
10869 | 1462 } |
1463 mv_cache[ 0 ][0]= mx; | |
1464 mv_cache[ 0 ][1]= my; | |
1465 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1466 mvd_cache[ 0 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1467 mvd_cache[ 0 ][1]= mpy; |
10869 | 1468 } |
1469 }else{ | |
11271
bf3436efe037
Replace ad-hoc fill rectangle by fill_rectangle().
michael
parents:
11208
diff
changeset
|
1470 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4); |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1471 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2); |
10869 | 1472 } |
1473 } | |
1474 } | |
1475 } else if( IS_DIRECT(mb_type) ) { | |
1476 ff_h264_pred_direct_motion(h, &mb_type); | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1477 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1478 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2); |
10869 | 1479 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
1480 } else { | |
11275 | 1481 int list, i; |
10869 | 1482 if(IS_16X16(mb_type)){ |
1483 for(list=0; list<h->list_count; list++){ | |
1484 if(IS_DIR(mb_type, 0, list)){ | |
1485 int ref; | |
1486 if(h->ref_count[list] > 1){ | |
1487 ref= decode_cabac_mb_ref(h, list, 0); | |
1488 if(ref >= (unsigned)h->ref_count[list]){ | |
1489 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1490 return -1; | |
1491 } | |
1492 }else | |
1493 ref=0; | |
1494 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); | |
11325
c4c8c8c426eb
Remove some unneeded fill_rectangle() for 16x16 blocks.
michael
parents:
11305
diff
changeset
|
1495 } |
10869 | 1496 } |
1497 for(list=0; list<h->list_count; list++){ | |
1498 if(IS_DIR(mb_type, 0, list)){ | |
11275 | 1499 int mx,my,mpx,mpy; |
1500 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1501 DECODE_CABAC_MB_MVD( h, list, 0) |
10869 | 1502 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1503 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1504 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1505 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
11325
c4c8c8c426eb
Remove some unneeded fill_rectangle() for 16x16 blocks.
michael
parents:
11305
diff
changeset
|
1506 } |
10869 | 1507 } |
1508 } | |
1509 else if(IS_16X8(mb_type)){ | |
1510 for(list=0; list<h->list_count; list++){ | |
1511 for(i=0; i<2; i++){ | |
1512 if(IS_DIR(mb_type, i, list)){ | |
1513 int ref; | |
1514 if(h->ref_count[list] > 1){ | |
1515 ref= decode_cabac_mb_ref( h, list, 8*i ); | |
1516 if(ref >= (unsigned)h->ref_count[list]){ | |
1517 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1518 return -1; | |
1519 } | |
1520 }else | |
1521 ref=0; | |
1522 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); | |
1523 }else | |
1524 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1525 } | |
1526 } | |
1527 for(list=0; list<h->list_count; list++){ | |
1528 for(i=0; i<2; i++){ | |
1529 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1530 int mx,my,mpx,mpy; |
1531 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1532 DECODE_CABAC_MB_MVD( h, list, 8*i) |
10869 | 1533 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1534 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1535 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2); |
10869 | 1536 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
1537 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1538 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2); |
10869 | 1539 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
1540 } | |
1541 } | |
1542 } | |
1543 }else{ | |
1544 assert(IS_8X16(mb_type)); | |
1545 for(list=0; list<h->list_count; list++){ | |
1546 for(i=0; i<2; i++){ | |
1547 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
1548 int ref; | |
1549 if(h->ref_count[list] > 1){ | |
1550 ref= decode_cabac_mb_ref( h, list, 4*i ); | |
1551 if(ref >= (unsigned)h->ref_count[list]){ | |
1552 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1553 return -1; | |
1554 } | |
1555 }else | |
1556 ref=0; | |
1557 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); | |
1558 }else | |
1559 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1560 } | |
1561 } | |
1562 for(list=0; list<h->list_count; list++){ | |
1563 for(i=0; i<2; i++){ | |
1564 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1565 int mx,my,mpx,mpy; |
1566 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1567 DECODE_CABAC_MB_MVD( h, list, 4*i) |
10869 | 1568 |
1569 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1570 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1571 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
1572 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1573 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2); |
10869 | 1574 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
1575 } | |
1576 } | |
1577 } | |
1578 } | |
1579 } | |
1580 | |
1581 if( IS_INTER( mb_type ) ) { | |
1582 h->chroma_pred_mode_table[mb_xy] = 0; | |
1583 write_back_motion( h, mb_type ); | |
1584 } | |
1585 | |
1586 if( !IS_INTRA16x16( mb_type ) ) { | |
1587 cbp = decode_cabac_mb_cbp_luma( h ); | |
1588 if(CHROMA) | |
1589 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; | |
1590 } | |
1591 | |
1592 h->cbp_table[mb_xy] = h->cbp = cbp; | |
1593 | |
1594 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1595 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
10869 | 1596 } |
1597 s->current_picture.mb_type[mb_xy]= mb_type; | |
1598 | |
1599 if( cbp || IS_INTRA16x16( mb_type ) ) { | |
1600 const uint8_t *scan, *scan8x8, *dc_scan; | |
1601 const uint32_t *qmul; | |
1602 | |
1603 if(IS_INTERLACED(mb_type)){ | |
1604 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; | |
1605 scan= s->qscale ? h->field_scan : h->field_scan_q0; | |
1606 dc_scan= luma_dc_field_scan; | |
1607 }else{ | |
1608 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; | |
1609 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; | |
1610 dc_scan= luma_dc_zigzag_scan; | |
1611 } | |
1612 | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1613 // decode_cabac_mb_dqp |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1614 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){ |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1615 int val = 1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1616 int ctx= 2; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1617 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1618 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) { |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1619 ctx= 3; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1620 val++; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1621 if(val > 102){ //prevent infinite loop |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1622 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1623 return -1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1624 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1625 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1626 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1627 if( val&0x01 ) |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1628 val= (val + 1)>>1 ; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1629 else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1630 val= -((val + 1)>>1); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1631 h->last_qscale_diff = val; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1632 s->qscale += val; |
11171 | 1633 if(((unsigned)s->qscale) > 51){ |
1634 if(s->qscale<0) s->qscale+= 52; | |
1635 else s->qscale-= 52; | |
1636 } | |
1637 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); | |
1638 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1639 }else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1640 h->last_qscale_diff=0; |
10869 | 1641 |
1642 if( IS_INTRA16x16( mb_type ) ) { | |
1643 int i; | |
1644 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); | |
11542 | 1645 decode_cabac_residual_dc( h, h->mb, 0, 0, dc_scan, 16); |
10869 | 1646 |
1647 if( cbp&15 ) { | |
1648 qmul = h->dequant4_coeff[0][s->qscale]; | |
1649 for( i = 0; i < 16; i++ ) { | |
1650 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1651 decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); |
10869 | 1652 } |
1653 } else { | |
1654 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1655 } | |
1656 } else { | |
1657 int i8x8, i4x4; | |
1658 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { | |
1659 if( cbp & (1<<i8x8) ) { | |
1660 if( IS_8x8DCT(mb_type) ) { | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1661 decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8, |
10869 | 1662 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); |
1663 } else { | |
1664 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; | |
1665 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { | |
1666 const int index = 4*i8x8 + i4x4; | |
1667 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); | |
1668 //START_TIMER | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1669 decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16); |
10869 | 1670 //STOP_TIMER("decode_residual") |
1671 } | |
1672 } | |
1673 } else { | |
1674 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
1675 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
1676 } | |
1677 } | |
1678 } | |
1679 | |
1680 if( cbp&0x30 ){ | |
1681 int c; | |
1682 for( c = 0; c < 2; c++ ) { | |
1683 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); | |
11542 | 1684 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, 4); |
10869 | 1685 } |
1686 } | |
1687 | |
1688 if( cbp&0x20 ) { | |
1689 int c, i; | |
1690 for( c = 0; c < 2; c++ ) { | |
1691 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; | |
1692 for( i = 0; i < 4; i++ ) { | |
1693 const int index = 16 + 4 * c + i; | |
1694 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1695 decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); |
10869 | 1696 } |
1697 } | |
1698 } else { | |
1699 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1700 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1701 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1702 } | |
1703 } else { | |
1704 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1705 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
1706 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1707 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1708 h->last_qscale_diff = 0; | |
1709 } | |
1710 | |
1711 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1712 write_back_non_zero_count(h); | |
1713 | |
1714 if(MB_MBAFF){ | |
1715 h->ref_count[0] >>= 1; | |
1716 h->ref_count[1] >>= 1; | |
1717 } | |
1718 | |
1719 return 0; | |
1720 } |