Mercurial > libavcodec.hg
annotate h264_cabac.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | c4c8c8c426eb |
children | a3790cd1c9ca |
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 | |
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 | |
1174 #if !CONFIG_SMALL | |
1175 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 ) { | |
1176 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1); | |
1177 } | |
1178 | |
1179 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 ) { | |
1180 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0); | |
1181 } | |
1182 #endif | |
1183 | |
1184 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) { | |
1185 #if CONFIG_SMALL | |
1186 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3); | |
1187 #else | |
1188 if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff); | |
1189 else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff); | |
1190 #endif | |
1191 } | |
1192 | |
1193 /** | |
1194 * decodes a macroblock | |
1195 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed | |
1196 */ | |
1197 int ff_h264_decode_mb_cabac(H264Context *h) { | |
1198 MpegEncContext * const s = &h->s; | |
1199 int mb_xy; | |
1200 int mb_type, partition_count, cbp = 0; | |
1201 int dct8x8_allowed= h->pps.transform_8x8_mode; | |
1202 | |
1203 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1204 | |
1205 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); | |
1206 if( h->slice_type_nos != FF_I_TYPE ) { | |
1207 int skip; | |
1208 /* a skipped mb needs the aff flag from the following mb */ | |
1209 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
1210 skip = h->next_mb_skipped; | |
1211 else | |
1212 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1213 /* read skip flags */ | |
1214 if( skip ) { | |
1215 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
1216 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
1217 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
1218 if(!h->next_mb_skipped) | |
1219 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1220 } | |
1221 | |
1222 decode_mb_skip(h); | |
1223 | |
1224 h->cbp_table[mb_xy] = 0; | |
1225 h->chroma_pred_mode_table[mb_xy] = 0; | |
1226 h->last_qscale_diff = 0; | |
1227 | |
1228 return 0; | |
1229 | |
1230 } | |
1231 } | |
1232 if(FRAME_MBAFF){ | |
1233 if( (s->mb_y&1) == 0 ) | |
1234 h->mb_mbaff = | |
1235 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1236 } | |
1237 | |
1238 h->prev_mb_skipped = 0; | |
1239 | |
11184
cc70f8c44019
Drop compute_mb_neighbors() and move fill_decode_neighbors() up to take its
michael
parents:
11183
diff
changeset
|
1240 fill_decode_neighbors(h, -(MB_FIELD)); |
10869 | 1241 |
1242 if( h->slice_type_nos == FF_B_TYPE ) { | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1243 int ctx = 0; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1244 assert(h->slice_type_nos == FF_B_TYPE); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1245 |
11185 | 1246 if( !IS_DIRECT( h->left_type[0]-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1247 ctx++; |
11185 | 1248 if( !IS_DIRECT( h->top_type-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1249 ctx++; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1250 |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1251 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
|
1252 mb_type= 0; /* B_Direct_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1253 }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
|
1254 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
|
1255 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1256 int bits; |
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+4] ) << 3; |
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] ) << 2; |
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] ) << 1; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1260 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
|
1261 if( bits < 8 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1262 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
|
1263 }else if( bits == 13 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1264 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
|
1265 goto decode_intra_mb; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1266 }else if( bits == 14 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1267 mb_type= 11; /* B_L1_L0_8x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1268 }else if( bits == 15 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1269 mb_type= 22; /* B_8x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1270 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1271 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
|
1272 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
|
1273 } |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1274 } |
10869 | 1275 partition_count= b_mb_type_info[mb_type].partition_count; |
1276 mb_type= b_mb_type_info[mb_type].type; | |
1277 } else if( h->slice_type_nos == FF_P_TYPE ) { | |
1278 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { | |
1279 /* P-type */ | |
1280 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { | |
1281 /* P_L0_D16x16, P_8x8 */ | |
1282 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); | |
1283 } else { | |
1284 /* P_L0_D8x16, P_L0_D16x8 */ | |
1285 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); | |
1286 } | |
1287 partition_count= p_mb_type_info[mb_type].partition_count; | |
1288 mb_type= p_mb_type_info[mb_type].type; | |
1289 } else { | |
1290 mb_type= decode_cabac_intra_mb_type(h, 17, 0); | |
1291 goto decode_intra_mb; | |
1292 } | |
1293 } else { | |
1294 mb_type= decode_cabac_intra_mb_type(h, 3, 1); | |
1295 if(h->slice_type == FF_SI_TYPE && mb_type) | |
1296 mb_type--; | |
1297 assert(h->slice_type_nos == FF_I_TYPE); | |
1298 decode_intra_mb: | |
1299 partition_count = 0; | |
1300 cbp= i_mb_type_info[mb_type].cbp; | |
1301 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
1302 mb_type= i_mb_type_info[mb_type].type; | |
1303 } | |
1304 if(MB_FIELD) | |
1305 mb_type |= MB_TYPE_INTERLACED; | |
1306 | |
1307 h->slice_table[ mb_xy ]= h->slice_num; | |
1308 | |
1309 if(IS_INTRA_PCM(mb_type)) { | |
1310 const uint8_t *ptr; | |
1311 | |
1312 // We assume these blocks are very rare so we do not optimize it. | |
1313 // FIXME The two following lines get the bitstream position in the cabac | |
1314 // decode, I think it should be done by a function in cabac.h (or cabac.c). | |
1315 ptr= h->cabac.bytestream; | |
1316 if(h->cabac.low&0x1) ptr--; | |
1317 if(CABAC_BITS==16){ | |
1318 if(h->cabac.low&0x1FF) ptr--; | |
1319 } | |
1320 | |
1321 // The pixels are stored in the same order as levels in h->mb array. | |
1322 memcpy(h->mb, ptr, 256); ptr+=256; | |
1323 if(CHROMA){ | |
1324 memcpy(h->mb+128, ptr, 128); ptr+=128; | |
1325 } | |
1326 | |
1327 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); | |
1328 | |
1329 // All blocks are present | |
1330 h->cbp_table[mb_xy] = 0x1ef; | |
1331 h->chroma_pred_mode_table[mb_xy] = 0; | |
1332 // In deblocking, the quantizer is 0 | |
1333 s->current_picture.qscale_table[mb_xy]= 0; | |
1334 // All coeffs are present | |
10906 | 1335 memset(h->non_zero_count[mb_xy], 16, 32); |
10869 | 1336 s->current_picture.mb_type[mb_xy]= mb_type; |
1337 h->last_qscale_diff = 0; | |
1338 return 0; | |
1339 } | |
1340 | |
1341 if(MB_MBAFF){ | |
1342 h->ref_count[0] <<= 1; | |
1343 h->ref_count[1] <<= 1; | |
1344 } | |
1345 | |
10907 | 1346 fill_decode_caches(h, mb_type); |
10869 | 1347 |
1348 if( IS_INTRA( mb_type ) ) { | |
1349 int i, pred_mode; | |
1350 if( IS_INTRA4x4( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1351 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) { |
10869 | 1352 mb_type |= MB_TYPE_8x8DCT; |
1353 for( i = 0; i < 16; i+=4 ) { | |
1354 int pred = pred_intra_mode( h, i ); | |
1355 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1356 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
1357 } | |
1358 } else { | |
1359 for( i = 0; i < 16; i++ ) { | |
1360 int pred = pred_intra_mode( h, i ); | |
1361 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1362 | |
1363 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); | |
1364 } | |
1365 } | |
1366 ff_h264_write_back_intra_pred_mode(h); | |
1367 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1; | |
1368 } else { | |
1369 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode ); | |
1370 if( h->intra16x16_pred_mode < 0 ) return -1; | |
1371 } | |
1372 if(CHROMA){ | |
1373 h->chroma_pred_mode_table[mb_xy] = | |
1374 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); | |
1375 | |
1376 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode ); | |
1377 if( pred_mode < 0 ) return -1; | |
1378 h->chroma_pred_mode= pred_mode; | |
1379 } | |
1380 } else if( partition_count == 4 ) { | |
1381 int i, j, sub_partition_count[4], list, ref[2][4]; | |
1382 | |
1383 if( h->slice_type_nos == FF_B_TYPE ) { | |
1384 for( i = 0; i < 4; i++ ) { | |
1385 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); | |
1386 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1387 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1388 } | |
1389 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | | |
1390 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
1391 ff_h264_pred_direct_motion(h, &mb_type); | |
1392 h->ref_cache[0][scan8[4]] = | |
1393 h->ref_cache[1][scan8[4]] = | |
1394 h->ref_cache[0][scan8[12]] = | |
1395 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
1396 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
|
1397 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 ); |
10869 | 1398 } |
1399 } else { | |
1400 for( i = 0; i < 4; i++ ) { | |
1401 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); | |
1402 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1403 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1404 } | |
1405 } | |
1406 | |
1407 for( list = 0; list < h->list_count; list++ ) { | |
1408 for( i = 0; i < 4; i++ ) { | |
1409 if(IS_DIRECT(h->sub_mb_type[i])) continue; | |
1410 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1411 if( h->ref_count[list] > 1 ){ | |
1412 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); | |
1413 if(ref[list][i] >= (unsigned)h->ref_count[list]){ | |
1414 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]); | |
1415 return -1; | |
1416 } | |
1417 }else | |
1418 ref[list][i] = 0; | |
1419 } else { | |
1420 ref[list][i] = -1; | |
1421 } | |
1422 h->ref_cache[list][ scan8[4*i]+1 ]= | |
1423 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
1424 } | |
1425 } | |
1426 | |
1427 if(dct8x8_allowed) | |
1428 dct8x8_allowed = get_dct8x8_allowed(h); | |
1429 | |
1430 for(list=0; list<h->list_count; list++){ | |
1431 for(i=0; i<4; i++){ | |
1432 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; | |
1433 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
|
1434 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2); |
10869 | 1435 continue; |
1436 } | |
1437 | |
1438 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ | |
1439 const int sub_mb_type= h->sub_mb_type[i]; | |
1440 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
1441 for(j=0; j<sub_partition_count[i]; j++){ | |
1442 int mpx, mpy; | |
1443 int mx, my; | |
1444 const int index= 4*i + block_width*j; | |
1445 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
|
1446 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
11275 | 1447 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
|
1448 DECODE_CABAC_MB_MVD( h, list, index) |
10869 | 1449 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1450 | |
1451 if(IS_SUB_8X8(sub_mb_type)){ | |
1452 mv_cache[ 1 ][0]= | |
1453 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
1454 mv_cache[ 1 ][1]= | |
1455 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
1456 | |
1457 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
|
1458 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx; |
10869 | 1459 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
|
1460 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy; |
10869 | 1461 }else if(IS_SUB_8X4(sub_mb_type)){ |
1462 mv_cache[ 1 ][0]= mx; | |
1463 mv_cache[ 1 ][1]= my; | |
1464 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1465 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
|
1466 mvd_cache[ 1 ][1]= mpy; |
10869 | 1467 }else if(IS_SUB_4X8(sub_mb_type)){ |
1468 mv_cache[ 8 ][0]= mx; | |
1469 mv_cache[ 8 ][1]= my; | |
1470 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1471 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
|
1472 mvd_cache[ 8 ][1]= mpy; |
10869 | 1473 } |
1474 mv_cache[ 0 ][0]= mx; | |
1475 mv_cache[ 0 ][1]= my; | |
1476 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1477 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
|
1478 mvd_cache[ 0 ][1]= mpy; |
10869 | 1479 } |
1480 }else{ | |
11271
bf3436efe037
Replace ad-hoc fill rectangle by fill_rectangle().
michael
parents:
11208
diff
changeset
|
1481 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
|
1482 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2); |
10869 | 1483 } |
1484 } | |
1485 } | |
1486 } else if( IS_DIRECT(mb_type) ) { | |
1487 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
|
1488 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
|
1489 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2); |
10869 | 1490 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
1491 } else { | |
11275 | 1492 int list, i; |
10869 | 1493 if(IS_16X16(mb_type)){ |
1494 for(list=0; list<h->list_count; list++){ | |
1495 if(IS_DIR(mb_type, 0, list)){ | |
1496 int ref; | |
1497 if(h->ref_count[list] > 1){ | |
1498 ref= decode_cabac_mb_ref(h, list, 0); | |
1499 if(ref >= (unsigned)h->ref_count[list]){ | |
1500 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1501 return -1; | |
1502 } | |
1503 }else | |
1504 ref=0; | |
1505 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
|
1506 } |
10869 | 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); |
11325
c4c8c8c426eb
Remove some unneeded fill_rectangle() for 16x16 blocks.
michael
parents:
11305
diff
changeset
|
1517 } |
10869 | 1518 } |
1519 } | |
1520 else if(IS_16X8(mb_type)){ | |
1521 for(list=0; list<h->list_count; list++){ | |
1522 for(i=0; i<2; i++){ | |
1523 if(IS_DIR(mb_type, i, list)){ | |
1524 int ref; | |
1525 if(h->ref_count[list] > 1){ | |
1526 ref= decode_cabac_mb_ref( h, list, 8*i ); | |
1527 if(ref >= (unsigned)h->ref_count[list]){ | |
1528 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1529 return -1; | |
1530 } | |
1531 }else | |
1532 ref=0; | |
1533 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); | |
1534 }else | |
1535 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1536 } | |
1537 } | |
1538 for(list=0; list<h->list_count; list++){ | |
1539 for(i=0; i<2; i++){ | |
1540 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1541 int mx,my,mpx,mpy; |
1542 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
|
1543 DECODE_CABAC_MB_MVD( h, list, 8*i) |
10869 | 1544 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1545 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1546 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2); |
10869 | 1547 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
1548 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1549 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2); |
10869 | 1550 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
1551 } | |
1552 } | |
1553 } | |
1554 }else{ | |
1555 assert(IS_8X16(mb_type)); | |
1556 for(list=0; list<h->list_count; list++){ | |
1557 for(i=0; i<2; i++){ | |
1558 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
1559 int ref; | |
1560 if(h->ref_count[list] > 1){ | |
1561 ref= decode_cabac_mb_ref( h, list, 4*i ); | |
1562 if(ref >= (unsigned)h->ref_count[list]){ | |
1563 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1564 return -1; | |
1565 } | |
1566 }else | |
1567 ref=0; | |
1568 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); | |
1569 }else | |
1570 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1571 } | |
1572 } | |
1573 for(list=0; list<h->list_count; list++){ | |
1574 for(i=0; i<2; i++){ | |
1575 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1576 int mx,my,mpx,mpy; |
1577 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
|
1578 DECODE_CABAC_MB_MVD( h, list, 4*i) |
10869 | 1579 |
1580 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
|
1581 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1582 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
1583 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1584 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2); |
10869 | 1585 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
1586 } | |
1587 } | |
1588 } | |
1589 } | |
1590 } | |
1591 | |
1592 if( IS_INTER( mb_type ) ) { | |
1593 h->chroma_pred_mode_table[mb_xy] = 0; | |
1594 write_back_motion( h, mb_type ); | |
1595 } | |
1596 | |
1597 if( !IS_INTRA16x16( mb_type ) ) { | |
1598 cbp = decode_cabac_mb_cbp_luma( h ); | |
1599 if(CHROMA) | |
1600 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; | |
1601 } | |
1602 | |
1603 h->cbp_table[mb_xy] = h->cbp = cbp; | |
1604 | |
1605 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
|
1606 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
10869 | 1607 } |
1608 s->current_picture.mb_type[mb_xy]= mb_type; | |
1609 | |
1610 if( cbp || IS_INTRA16x16( mb_type ) ) { | |
1611 const uint8_t *scan, *scan8x8, *dc_scan; | |
1612 const uint32_t *qmul; | |
1613 | |
1614 if(IS_INTERLACED(mb_type)){ | |
1615 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; | |
1616 scan= s->qscale ? h->field_scan : h->field_scan_q0; | |
1617 dc_scan= luma_dc_field_scan; | |
1618 }else{ | |
1619 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; | |
1620 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; | |
1621 dc_scan= luma_dc_zigzag_scan; | |
1622 } | |
1623 | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1624 // decode_cabac_mb_dqp |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1625 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
|
1626 int val = 1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1627 int ctx= 2; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1628 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1629 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
|
1630 ctx= 3; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1631 val++; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1632 if(val > 102){ //prevent infinite loop |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1633 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
|
1634 return -1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1635 } |
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 if( val&0x01 ) |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1639 val= (val + 1)>>1 ; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1640 else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1641 val= -((val + 1)>>1); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1642 h->last_qscale_diff = val; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1643 s->qscale += val; |
11171 | 1644 if(((unsigned)s->qscale) > 51){ |
1645 if(s->qscale<0) s->qscale+= 52; | |
1646 else s->qscale-= 52; | |
1647 } | |
1648 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); | |
1649 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
|
1650 }else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1651 h->last_qscale_diff=0; |
10869 | 1652 |
1653 if( IS_INTRA16x16( mb_type ) ) { | |
1654 int i; | |
1655 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); | |
1656 decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16); | |
1657 | |
1658 if( cbp&15 ) { | |
1659 qmul = h->dequant4_coeff[0][s->qscale]; | |
1660 for( i = 0; i < 16; i++ ) { | |
1661 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); | |
1662 decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); | |
1663 } | |
1664 } else { | |
1665 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1666 } | |
1667 } else { | |
1668 int i8x8, i4x4; | |
1669 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { | |
1670 if( cbp & (1<<i8x8) ) { | |
1671 if( IS_8x8DCT(mb_type) ) { | |
1672 decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8, | |
1673 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); | |
1674 } else { | |
1675 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; | |
1676 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { | |
1677 const int index = 4*i8x8 + i4x4; | |
1678 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); | |
1679 //START_TIMER | |
1680 decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16); | |
1681 //STOP_TIMER("decode_residual") | |
1682 } | |
1683 } | |
1684 } else { | |
1685 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
1686 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
1687 } | |
1688 } | |
1689 } | |
1690 | |
1691 if( cbp&0x30 ){ | |
1692 int c; | |
1693 for( c = 0; c < 2; c++ ) { | |
1694 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); | |
1695 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4); | |
1696 } | |
1697 } | |
1698 | |
1699 if( cbp&0x20 ) { | |
1700 int c, i; | |
1701 for( c = 0; c < 2; c++ ) { | |
1702 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; | |
1703 for( i = 0; i < 4; i++ ) { | |
1704 const int index = 16 + 4 * c + i; | |
1705 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); | |
1706 decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); | |
1707 } | |
1708 } | |
1709 } else { | |
1710 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1711 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1712 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1713 } | |
1714 } else { | |
1715 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1716 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
1717 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1718 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1719 h->last_qscale_diff = 0; | |
1720 } | |
1721 | |
1722 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1723 write_back_non_zero_count(h); | |
1724 | |
1725 if(MB_MBAFF){ | |
1726 h->ref_count[0] >>= 1; | |
1727 h->ref_count[1] >>= 1; | |
1728 } | |
1729 | |
1730 return 0; | |
1731 } |