Mercurial > libavcodec.hg
annotate h264_cabac.c @ 11300:1f512abdf680 libavcodec
Simplify code to set cbp_*
this seems 1 cpu cycle slower even though we practically just remove code.
Speed loss seems caused by the merge of if(left_type), iam commiting this
anyway as i cant imagine this to be anything but compiler messup.
author | michael |
---|---|
date | Fri, 26 Feb 2010 09:13:40 +0000 |
parents | c12d6c6c027e |
children | 1a349d669184 |
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; | |
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); | |
830 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]); | |
831 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08); | |
832 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1; | |
833 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01); | |
834 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2; | |
835 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02); | |
836 cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3; | |
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 | |
11275 | 915 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){ |
916 *mvda= 0; | |
10869 | 917 return 0; |
11275 | 918 } |
10869 | 919 |
920 mvd= 1; | |
11207
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
921 ctxbase+= 3; |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
922 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
|
923 if( mvd < 4 ) |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
924 ctxbase++; |
10869 | 925 mvd++; |
926 } | |
927 | |
928 if( mvd >= 9 ) { | |
929 int k = 3; | |
930 while( get_cabac_bypass( &h->cabac ) ) { | |
931 mvd += 1 << k; | |
932 k++; | |
933 if(k>24){ | |
934 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); | |
935 return INT_MIN; | |
936 } | |
937 } | |
938 while( k-- ) { | |
11208 | 939 mvd += get_cabac_bypass( &h->cabac )<<k; |
10869 | 940 } |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
941 *mvda=mvd < 70 ? mvd : 70; |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
942 }else |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
943 *mvda=mvd; |
10869 | 944 return get_cabac_bypass_sign( &h->cabac, -mvd ); |
945 } | |
946 | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
947 #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
|
948 {\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
949 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
|
950 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
|
951 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
|
952 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
|
953 \ |
11275 | 954 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\ |
955 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
|
956 } |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
957 |
10869 | 958 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) { |
959 int nza, nzb; | |
960 int ctx = 0; | |
961 | |
962 if( is_dc ) { | |
963 if( cat == 0 ) { | |
964 nza = h->left_cbp&0x100; | |
965 nzb = h-> top_cbp&0x100; | |
966 } else { | |
967 nza = (h->left_cbp>>(6+idx))&0x01; | |
968 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
969 } | |
970 } else { | |
971 assert(cat == 1 || cat == 2 || cat == 4); | |
972 nza = h->non_zero_count_cache[scan8[idx] - 1]; | |
973 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
974 } | |
975 | |
976 if( nza > 0 ) | |
977 ctx++; | |
978 | |
979 if( nzb > 0 ) | |
980 ctx += 2; | |
981 | |
982 return ctx + 4 * cat; | |
983 } | |
984 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10930
diff
changeset
|
985 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = { |
10869 | 986 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
987 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
988 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
989 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
990 }; | |
991 | |
992 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 ) { | |
993 static const int significant_coeff_flag_offset[2][6] = { | |
994 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
995 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
996 }; | |
997 static const int last_coeff_flag_offset[2][6] = { | |
998 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
999 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
1000 }; | |
1001 static const int coeff_abs_level_m1_offset[6] = { | |
1002 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
1003 }; | |
1004 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { | |
1005 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, | |
1006 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, | |
1007 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
1008 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, | |
1009 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
1010 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
1011 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
1012 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
1013 }; | |
1014 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0). | |
1015 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter). | |
1016 * map node ctx => cabac ctx for level=1 */ | |
1017 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 }; | |
1018 /* map node ctx => cabac ctx for level>1 */ | |
1019 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 }; | |
1020 static const uint8_t coeff_abs_level_transition[2][8] = { | |
1021 /* update node ctx after decoding a level=1 */ | |
1022 { 1, 2, 3, 3, 4, 5, 6, 7 }, | |
1023 /* update node ctx after decoding a level>1 */ | |
1024 { 4, 4, 4, 4, 5, 6, 7, 7 } | |
1025 }; | |
1026 | |
1027 int index[64]; | |
1028 | |
1029 int av_unused last; | |
1030 int coeff_count = 0; | |
1031 int node_ctx = 0; | |
1032 | |
1033 uint8_t *significant_coeff_ctx_base; | |
1034 uint8_t *last_coeff_ctx_base; | |
1035 uint8_t *abs_level_m1_ctx_base; | |
1036 | |
1037 #if !ARCH_X86 | |
1038 #define CABAC_ON_STACK | |
1039 #endif | |
1040 #ifdef CABAC_ON_STACK | |
1041 #define CC &cc | |
1042 CABACContext cc; | |
1043 cc.range = h->cabac.range; | |
1044 cc.low = h->cabac.low; | |
1045 cc.bytestream= h->cabac.bytestream; | |
1046 #else | |
1047 #define CC &h->cabac | |
1048 #endif | |
1049 | |
1050 | |
1051 /* cat: 0-> DC 16x16 n = 0 | |
1052 * 1-> AC 16x16 n = luma4x4idx | |
1053 * 2-> Luma4x4 n = luma4x4idx | |
1054 * 3-> DC Chroma n = iCbCr | |
1055 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx | |
1056 * 5-> Luma8x8 n = 4 * luma8x8idx | |
1057 */ | |
1058 | |
1059 /* read coded block flag */ | |
1060 if( is_dc || cat != 5 ) { | |
1061 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) { | |
1062 if( !is_dc ) | |
1063 h->non_zero_count_cache[scan8[n]] = 0; | |
1064 | |
1065 #ifdef CABAC_ON_STACK | |
1066 h->cabac.range = cc.range ; | |
1067 h->cabac.low = cc.low ; | |
1068 h->cabac.bytestream= cc.bytestream; | |
1069 #endif | |
1070 return; | |
1071 } | |
1072 } | |
1073 | |
1074 significant_coeff_ctx_base = h->cabac_state | |
1075 + significant_coeff_flag_offset[MB_FIELD][cat]; | |
1076 last_coeff_ctx_base = h->cabac_state | |
1077 + last_coeff_flag_offset[MB_FIELD][cat]; | |
1078 abs_level_m1_ctx_base = h->cabac_state | |
1079 + coeff_abs_level_m1_offset[cat]; | |
1080 | |
1081 if( !is_dc && cat == 5 ) { | |
1082 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
1083 for(last= 0; last < coefs; last++) { \ | |
1084 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \ | |
1085 if( get_cabac( CC, sig_ctx )) { \ | |
1086 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ | |
1087 index[coeff_count++] = last; \ | |
1088 if( get_cabac( CC, last_ctx ) ) { \ | |
1089 last= max_coeff; \ | |
1090 break; \ | |
1091 } \ | |
1092 } \ | |
1093 }\ | |
1094 if( last == max_coeff -1 ) {\ | |
1095 index[coeff_count++] = last;\ | |
1096 } | |
1097 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; | |
1098 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) | |
1099 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); | |
1100 } else { | |
1101 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
1102 #else | |
1103 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); | |
1104 } else { | |
1105 DECODE_SIGNIFICANCE( max_coeff - 1, last, last ); | |
1106 #endif | |
1107 } | |
1108 assert(coeff_count > 0); | |
1109 | |
1110 if( is_dc ) { | |
1111 if( cat == 0 ) | |
1112 h->cbp_table[h->mb_xy] |= 0x100; | |
1113 else | |
1114 h->cbp_table[h->mb_xy] |= 0x40 << n; | |
1115 } else { | |
1116 if( cat == 5 ) | |
1117 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); | |
1118 else { | |
1119 assert( cat == 1 || cat == 2 || cat == 4 ); | |
1120 h->non_zero_count_cache[scan8[n]] = coeff_count; | |
1121 } | |
1122 } | |
1123 | |
1124 do { | |
1125 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1126 | |
1127 int j= scantable[index[--coeff_count]]; | |
1128 | |
1129 if( get_cabac( CC, ctx ) == 0 ) { | |
1130 node_ctx = coeff_abs_level_transition[0][node_ctx]; | |
1131 if( is_dc ) { | |
1132 block[j] = get_cabac_bypass_sign( CC, -1); | |
1133 }else{ | |
1134 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; | |
1135 } | |
1136 } else { | |
1137 int coeff_abs = 2; | |
1138 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1139 node_ctx = coeff_abs_level_transition[1][node_ctx]; | |
1140 | |
1141 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { | |
1142 coeff_abs++; | |
1143 } | |
1144 | |
1145 if( coeff_abs >= 15 ) { | |
1146 int j = 0; | |
1147 while( get_cabac_bypass( CC ) ) { | |
1148 j++; | |
1149 } | |
1150 | |
1151 coeff_abs=1; | |
1152 while( j-- ) { | |
1153 coeff_abs += coeff_abs + get_cabac_bypass( CC ); | |
1154 } | |
1155 coeff_abs+= 14; | |
1156 } | |
1157 | |
1158 if( is_dc ) { | |
1159 block[j] = get_cabac_bypass_sign( CC, -coeff_abs ); | |
1160 }else{ | |
1161 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6; | |
1162 } | |
1163 } | |
1164 } while( coeff_count ); | |
1165 #ifdef CABAC_ON_STACK | |
1166 h->cabac.range = cc.range ; | |
1167 h->cabac.low = cc.low ; | |
1168 h->cabac.bytestream= cc.bytestream; | |
1169 #endif | |
1170 | |
1171 } | |
1172 | |
1173 #if !CONFIG_SMALL | |
1174 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 ) { | |
1175 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1); | |
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 #endif | |
1182 | |
1183 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) { | |
1184 #if CONFIG_SMALL | |
1185 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3); | |
1186 #else | |
1187 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff); | |
1188 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff); | |
1189 #endif | |
1190 } | |
1191 | |
1192 /** | |
1193 * decodes a macroblock | |
1194 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
1195 */ | |
1196 int ff_h264_decode_mb_cabac(H264Context *h) { | |
1197 MpegEncContext * const s = &h->s; | |
1198 int mb_xy; | |
1199 int mb_type, partition_count, cbp = 0; | |
1200 int dct8x8_allowed= h->pps.transform_8x8_mode; | |
1201 | |
1202 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1203 | |
1204 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); | |
1205 if( h->slice_type_nos != FF_I_TYPE ) { | |
1206 int skip; | |
1207 /* a skipped mb needs the aff flag from the following mb */ | |
1208 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
1209 skip = h->next_mb_skipped; | |
1210 else | |
1211 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1212 /* read skip flags */ | |
1213 if( skip ) { | |
1214 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
1215 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
1216 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
1217 if(!h->next_mb_skipped) | |
1218 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1219 } | |
1220 | |
1221 decode_mb_skip(h); | |
1222 | |
1223 h->cbp_table[mb_xy] = 0; | |
1224 h->chroma_pred_mode_table[mb_xy] = 0; | |
1225 h->last_qscale_diff = 0; | |
1226 | |
1227 return 0; | |
1228 | |
1229 } | |
1230 } | |
1231 if(FRAME_MBAFF){ | |
1232 if( (s->mb_y&1) == 0 ) | |
1233 h->mb_mbaff = | |
1234 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1235 } | |
1236 | |
1237 h->prev_mb_skipped = 0; | |
1238 | |
11184
cc70f8c44019
Drop compute_mb_neighbors() and move fill_decode_neighbors() up to take its
michael
parents:
11183
diff
changeset
|
1239 fill_decode_neighbors(h, -(MB_FIELD)); |
10869 | 1240 |
1241 if( h->slice_type_nos == FF_B_TYPE ) { | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1242 int ctx = 0; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1243 assert(h->slice_type_nos == FF_B_TYPE); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1244 |
11185 | 1245 if( !IS_DIRECT( h->left_type[0]-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1246 ctx++; |
11185 | 1247 if( !IS_DIRECT( h->top_type-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1248 ctx++; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1249 |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1250 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
|
1251 mb_type= 0; /* B_Direct_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1252 }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
|
1253 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
|
1254 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1255 int bits; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1256 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1257 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1258 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1259 bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1260 if( bits < 8 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1261 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
|
1262 }else if( bits == 13 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1263 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
|
1264 goto decode_intra_mb; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1265 }else if( bits == 14 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1266 mb_type= 11; /* B_L1_L0_8x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1267 }else if( bits == 15 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1268 mb_type= 22; /* B_8x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1269 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1270 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1271 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
|
1272 } |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1273 } |
10869 | 1274 partition_count= b_mb_type_info[mb_type].partition_count; |
1275 mb_type= b_mb_type_info[mb_type].type; | |
1276 } else if( h->slice_type_nos == FF_P_TYPE ) { | |
1277 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { | |
1278 /* P-type */ | |
1279 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { | |
1280 /* P_L0_D16x16, P_8x8 */ | |
1281 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); | |
1282 } else { | |
1283 /* P_L0_D8x16, P_L0_D16x8 */ | |
1284 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); | |
1285 } | |
1286 partition_count= p_mb_type_info[mb_type].partition_count; | |
1287 mb_type= p_mb_type_info[mb_type].type; | |
1288 } else { | |
1289 mb_type= decode_cabac_intra_mb_type(h, 17, 0); | |
1290 goto decode_intra_mb; | |
1291 } | |
1292 } else { | |
1293 mb_type= decode_cabac_intra_mb_type(h, 3, 1); | |
1294 if(h->slice_type == FF_SI_TYPE && mb_type) | |
1295 mb_type--; | |
1296 assert(h->slice_type_nos == FF_I_TYPE); | |
1297 decode_intra_mb: | |
1298 partition_count = 0; | |
1299 cbp= i_mb_type_info[mb_type].cbp; | |
1300 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
1301 mb_type= i_mb_type_info[mb_type].type; | |
1302 } | |
1303 if(MB_FIELD) | |
1304 mb_type |= MB_TYPE_INTERLACED; | |
1305 | |
1306 h->slice_table[ mb_xy ]= h->slice_num; | |
1307 | |
1308 if(IS_INTRA_PCM(mb_type)) { | |
1309 const uint8_t *ptr; | |
1310 | |
1311 // We assume these blocks are very rare so we do not optimize it. | |
1312 // FIXME The two following lines get the bitstream position in the cabac | |
1313 // decode, I think it should be done by a function in cabac.h (or cabac.c). | |
1314 ptr= h->cabac.bytestream; | |
1315 if(h->cabac.low&0x1) ptr--; | |
1316 if(CABAC_BITS==16){ | |
1317 if(h->cabac.low&0x1FF) ptr--; | |
1318 } | |
1319 | |
1320 // The pixels are stored in the same order as levels in h->mb array. | |
1321 memcpy(h->mb, ptr, 256); ptr+=256; | |
1322 if(CHROMA){ | |
1323 memcpy(h->mb+128, ptr, 128); ptr+=128; | |
1324 } | |
1325 | |
1326 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); | |
1327 | |
1328 // All blocks are present | |
1329 h->cbp_table[mb_xy] = 0x1ef; | |
1330 h->chroma_pred_mode_table[mb_xy] = 0; | |
1331 // In deblocking, the quantizer is 0 | |
1332 s->current_picture.qscale_table[mb_xy]= 0; | |
1333 // All coeffs are present | |
10906 | 1334 memset(h->non_zero_count[mb_xy], 16, 32); |
10869 | 1335 s->current_picture.mb_type[mb_xy]= mb_type; |
1336 h->last_qscale_diff = 0; | |
1337 return 0; | |
1338 } | |
1339 | |
1340 if(MB_MBAFF){ | |
1341 h->ref_count[0] <<= 1; | |
1342 h->ref_count[1] <<= 1; | |
1343 } | |
1344 | |
10907 | 1345 fill_decode_caches(h, mb_type); |
10869 | 1346 |
1347 if( IS_INTRA( mb_type ) ) { | |
1348 int i, pred_mode; | |
1349 if( IS_INTRA4x4( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1350 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) { |
10869 | 1351 mb_type |= MB_TYPE_8x8DCT; |
1352 for( i = 0; i < 16; i+=4 ) { | |
1353 int pred = pred_intra_mode( h, i ); | |
1354 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1355 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
1356 } | |
1357 } else { | |
1358 for( i = 0; i < 16; i++ ) { | |
1359 int pred = pred_intra_mode( h, i ); | |
1360 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1361 | |
1362 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); | |
1363 } | |
1364 } | |
1365 ff_h264_write_back_intra_pred_mode(h); | |
1366 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1; | |
1367 } else { | |
1368 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode ); | |
1369 if( h->intra16x16_pred_mode < 0 ) return -1; | |
1370 } | |
1371 if(CHROMA){ | |
1372 h->chroma_pred_mode_table[mb_xy] = | |
1373 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); | |
1374 | |
1375 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode ); | |
1376 if( pred_mode < 0 ) return -1; | |
1377 h->chroma_pred_mode= pred_mode; | |
1378 } | |
1379 } else if( partition_count == 4 ) { | |
1380 int i, j, sub_partition_count[4], list, ref[2][4]; | |
1381 | |
1382 if( h->slice_type_nos == FF_B_TYPE ) { | |
1383 for( i = 0; i < 4; i++ ) { | |
1384 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); | |
1385 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1386 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1387 } | |
1388 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | | |
1389 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
1390 ff_h264_pred_direct_motion(h, &mb_type); | |
1391 h->ref_cache[0][scan8[4]] = | |
1392 h->ref_cache[1][scan8[4]] = | |
1393 h->ref_cache[0][scan8[12]] = | |
1394 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
1395 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
|
1396 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 ); |
10869 | 1397 } |
1398 } else { | |
1399 for( i = 0; i < 4; i++ ) { | |
1400 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); | |
1401 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1402 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1403 } | |
1404 } | |
1405 | |
1406 for( list = 0; list < h->list_count; list++ ) { | |
1407 for( i = 0; i < 4; i++ ) { | |
1408 if(IS_DIRECT(h->sub_mb_type[i])) continue; | |
1409 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1410 if( h->ref_count[list] > 1 ){ | |
1411 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); | |
1412 if(ref[list][i] >= (unsigned)h->ref_count[list]){ | |
1413 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]); | |
1414 return -1; | |
1415 } | |
1416 }else | |
1417 ref[list][i] = 0; | |
1418 } else { | |
1419 ref[list][i] = -1; | |
1420 } | |
1421 h->ref_cache[list][ scan8[4*i]+1 ]= | |
1422 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
1423 } | |
1424 } | |
1425 | |
1426 if(dct8x8_allowed) | |
1427 dct8x8_allowed = get_dct8x8_allowed(h); | |
1428 | |
1429 for(list=0; list<h->list_count; list++){ | |
1430 for(i=0; i<4; i++){ | |
1431 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; | |
1432 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
|
1433 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2); |
10869 | 1434 continue; |
1435 } | |
1436 | |
1437 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ | |
1438 const int sub_mb_type= h->sub_mb_type[i]; | |
1439 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
1440 for(j=0; j<sub_partition_count[i]; j++){ | |
1441 int mpx, mpy; | |
1442 int mx, my; | |
1443 const int index= 4*i + block_width*j; | |
1444 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
|
1445 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
11275 | 1446 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
|
1447 DECODE_CABAC_MB_MVD( h, list, index) |
10869 | 1448 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1449 | |
1450 if(IS_SUB_8X8(sub_mb_type)){ | |
1451 mv_cache[ 1 ][0]= | |
1452 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
1453 mv_cache[ 1 ][1]= | |
1454 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
1455 | |
1456 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
|
1457 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx; |
10869 | 1458 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
|
1459 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy; |
10869 | 1460 }else if(IS_SUB_8X4(sub_mb_type)){ |
1461 mv_cache[ 1 ][0]= mx; | |
1462 mv_cache[ 1 ][1]= my; | |
1463 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1464 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
|
1465 mvd_cache[ 1 ][1]= mpy; |
10869 | 1466 }else if(IS_SUB_4X8(sub_mb_type)){ |
1467 mv_cache[ 8 ][0]= mx; | |
1468 mv_cache[ 8 ][1]= my; | |
1469 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1470 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
|
1471 mvd_cache[ 8 ][1]= mpy; |
10869 | 1472 } |
1473 mv_cache[ 0 ][0]= mx; | |
1474 mv_cache[ 0 ][1]= my; | |
1475 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1476 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
|
1477 mvd_cache[ 0 ][1]= mpy; |
10869 | 1478 } |
1479 }else{ | |
11271
bf3436efe037
Replace ad-hoc fill rectangle by fill_rectangle().
michael
parents:
11208
diff
changeset
|
1480 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
|
1481 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2); |
10869 | 1482 } |
1483 } | |
1484 } | |
1485 } else if( IS_DIRECT(mb_type) ) { | |
1486 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
|
1487 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
|
1488 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2); |
10869 | 1489 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
1490 } else { | |
11275 | 1491 int list, i; |
10869 | 1492 if(IS_16X16(mb_type)){ |
1493 for(list=0; list<h->list_count; list++){ | |
1494 if(IS_DIR(mb_type, 0, list)){ | |
1495 int ref; | |
1496 if(h->ref_count[list] > 1){ | |
1497 ref= decode_cabac_mb_ref(h, list, 0); | |
1498 if(ref >= (unsigned)h->ref_count[list]){ | |
1499 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1500 return -1; | |
1501 } | |
1502 }else | |
1503 ref=0; | |
1504 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); | |
1505 }else | |
1506 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 | |
1507 } | |
1508 for(list=0; list<h->list_count; list++){ | |
1509 if(IS_DIR(mb_type, 0, list)){ | |
11275 | 1510 int mx,my,mpx,mpy; |
1511 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
|
1512 DECODE_CABAC_MB_MVD( h, list, 0) |
10869 | 1513 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1514 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1515 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1516 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
1517 }else | |
1518 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4); | |
1519 } | |
1520 } | |
1521 else if(IS_16X8(mb_type)){ | |
1522 for(list=0; list<h->list_count; list++){ | |
1523 for(i=0; i<2; i++){ | |
1524 if(IS_DIR(mb_type, i, list)){ | |
1525 int ref; | |
1526 if(h->ref_count[list] > 1){ | |
1527 ref= decode_cabac_mb_ref( h, list, 8*i ); | |
1528 if(ref >= (unsigned)h->ref_count[list]){ | |
1529 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1530 return -1; | |
1531 } | |
1532 }else | |
1533 ref=0; | |
1534 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); | |
1535 }else | |
1536 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1537 } | |
1538 } | |
1539 for(list=0; list<h->list_count; list++){ | |
1540 for(i=0; i<2; i++){ | |
1541 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1542 int mx,my,mpx,mpy; |
1543 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
|
1544 DECODE_CABAC_MB_MVD( h, list, 8*i) |
10869 | 1545 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1546 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1547 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2); |
10869 | 1548 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
1549 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1550 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2); |
10869 | 1551 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
1552 } | |
1553 } | |
1554 } | |
1555 }else{ | |
1556 assert(IS_8X16(mb_type)); | |
1557 for(list=0; list<h->list_count; list++){ | |
1558 for(i=0; i<2; i++){ | |
1559 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
1560 int ref; | |
1561 if(h->ref_count[list] > 1){ | |
1562 ref= decode_cabac_mb_ref( h, list, 4*i ); | |
1563 if(ref >= (unsigned)h->ref_count[list]){ | |
1564 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1565 return -1; | |
1566 } | |
1567 }else | |
1568 ref=0; | |
1569 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); | |
1570 }else | |
1571 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1572 } | |
1573 } | |
1574 for(list=0; list<h->list_count; list++){ | |
1575 for(i=0; i<2; i++){ | |
1576 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1577 int mx,my,mpx,mpy; |
1578 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
|
1579 DECODE_CABAC_MB_MVD( h, list, 4*i) |
10869 | 1580 |
1581 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
|
1582 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1583 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
1584 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1585 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2); |
10869 | 1586 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
1587 } | |
1588 } | |
1589 } | |
1590 } | |
1591 } | |
1592 | |
1593 if( IS_INTER( mb_type ) ) { | |
1594 h->chroma_pred_mode_table[mb_xy] = 0; | |
1595 write_back_motion( h, mb_type ); | |
1596 } | |
1597 | |
1598 if( !IS_INTRA16x16( mb_type ) ) { | |
1599 cbp = decode_cabac_mb_cbp_luma( h ); | |
1600 if(CHROMA) | |
1601 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; | |
1602 } | |
1603 | |
1604 h->cbp_table[mb_xy] = h->cbp = cbp; | |
1605 | |
1606 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
|
1607 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
10869 | 1608 } |
1609 s->current_picture.mb_type[mb_xy]= mb_type; | |
1610 | |
1611 if( cbp || IS_INTRA16x16( mb_type ) ) { | |
1612 const uint8_t *scan, *scan8x8, *dc_scan; | |
1613 const uint32_t *qmul; | |
1614 | |
1615 if(IS_INTERLACED(mb_type)){ | |
1616 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; | |
1617 scan= s->qscale ? h->field_scan : h->field_scan_q0; | |
1618 dc_scan= luma_dc_field_scan; | |
1619 }else{ | |
1620 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; | |
1621 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; | |
1622 dc_scan= luma_dc_zigzag_scan; | |
1623 } | |
1624 | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1625 // decode_cabac_mb_dqp |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1626 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
|
1627 int val = 1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1628 int ctx= 2; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1629 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1630 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
|
1631 ctx= 3; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1632 val++; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1633 if(val > 102){ //prevent infinite loop |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1634 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
|
1635 return -1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1636 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1637 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1638 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1639 if( val&0x01 ) |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1640 val= (val + 1)>>1 ; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1641 else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1642 val= -((val + 1)>>1); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1643 h->last_qscale_diff = val; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1644 s->qscale += val; |
11171 | 1645 if(((unsigned)s->qscale) > 51){ |
1646 if(s->qscale<0) s->qscale+= 52; | |
1647 else s->qscale-= 52; | |
1648 } | |
1649 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); | |
1650 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
|
1651 }else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1652 h->last_qscale_diff=0; |
10869 | 1653 |
1654 if( IS_INTRA16x16( mb_type ) ) { | |
1655 int i; | |
1656 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); | |
1657 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16); | |
1658 | |
1659 if( cbp&15 ) { | |
1660 qmul = h->dequant4_coeff[0][s->qscale]; | |
1661 for( i = 0; i < 16; i++ ) { | |
1662 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); | |
1663 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); | |
1664 } | |
1665 } else { | |
1666 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1667 } | |
1668 } else { | |
1669 int i8x8, i4x4; | |
1670 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { | |
1671 if( cbp & (1<<i8x8) ) { | |
1672 if( IS_8x8DCT(mb_type) ) { | |
1673 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
1674 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); | |
1675 } else { | |
1676 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; | |
1677 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { | |
1678 const int index = 4*i8x8 + i4x4; | |
1679 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); | |
1680 //START_TIMER | |
1681 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16); | |
1682 //STOP_TIMER("decode_residual") | |
1683 } | |
1684 } | |
1685 } else { | |
1686 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
1687 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
1688 } | |
1689 } | |
1690 } | |
1691 | |
1692 if( cbp&0x30 ){ | |
1693 int c; | |
1694 for( c = 0; c < 2; c++ ) { | |
1695 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); | |
1696 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4); | |
1697 } | |
1698 } | |
1699 | |
1700 if( cbp&0x20 ) { | |
1701 int c, i; | |
1702 for( c = 0; c < 2; c++ ) { | |
1703 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; | |
1704 for( i = 0; i < 4; i++ ) { | |
1705 const int index = 16 + 4 * c + i; | |
1706 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); | |
1707 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); | |
1708 } | |
1709 } | |
1710 } else { | |
1711 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1712 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1713 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1714 } | |
1715 } else { | |
1716 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1717 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
1718 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1719 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1720 h->last_qscale_diff = 0; | |
1721 } | |
1722 | |
1723 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1724 write_back_non_zero_count(h); | |
1725 | |
1726 if(MB_MBAFF){ | |
1727 h->ref_count[0] >>= 1; | |
1728 h->ref_count[1] >>= 1; | |
1729 } | |
1730 | |
1731 return 0; | |
1732 } |