Mercurial > libavcodec.hg
annotate h264_cabac.c @ 12223:93e27a5401de libavcodec
Convert VP8 macroblock structures to a ring buffer.
Uses a slightly nonintuitive ring buffer size of (width+height*2) to simplify
addressing logic.
Also split out the segmentation map to a separate structure, necessary to
implement the ring buffer.
author | darkshikari |
---|---|
date | Thu, 22 Jul 2010 11:45:18 +0000 |
parents | 7dd2a45249a9 |
children |
rev | line source |
---|---|
10869 | 1 /* |
2 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding | |
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11556
diff
changeset
|
23 * @file |
10869 | 24 * H.264 / AVC / MPEG4 part10 cabac decoding. |
25 * @author Michael Niedermayer <michaelni@gmx.at> | |
26 */ | |
27 | |
10893
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10869
diff
changeset
|
28 #define CABAC 1 |
2aafcafbe1f0
Replace cabac checks in inline functions from h264.h with constants.
michael
parents:
10869
diff
changeset
|
29 |
10869 | 30 #include "internal.h" |
31 #include "dsputil.h" | |
32 #include "avcodec.h" | |
33 #include "h264.h" | |
34 #include "h264data.h" | |
35 #include "h264_mvpred.h" | |
36 #include "golomb.h" | |
37 | |
38 #include "cabac.h" | |
39 #if ARCH_X86 | |
40 #include "x86/h264_i386.h" | |
41 #endif | |
42 | |
43 //#undef NDEBUG | |
44 #include <assert.h> | |
45 | |
46 /* Cabac pre state table */ | |
47 | |
48 static const int8_t cabac_context_init_I[460][2] = | |
49 { | |
50 /* 0 - 10 */ | |
51 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 }, | |
52 { 2, 54 }, { 3, 74 }, { -28,127 }, { -23, 104 }, | |
53 { -6, 53 }, { -1, 54 }, { 7, 51 }, | |
54 | |
55 /* 11 - 23 unsused for I */ | |
56 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
57 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
58 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
59 { 0, 0 }, | |
60 | |
61 /* 24- 39 */ | |
62 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
63 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
64 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
65 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
66 | |
67 /* 40 - 53 */ | |
68 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
69 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
70 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
71 { 0, 0 }, { 0, 0 }, | |
72 | |
73 /* 54 - 59 */ | |
74 { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, | |
75 { 0, 0 }, { 0, 0 }, | |
76 | |
77 /* 60 - 69 */ | |
78 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
79 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
80 { 13, 41 }, { 3, 62 }, | |
81 | |
82 /* 70 -> 87 */ | |
83 { 0, 11 }, { 1, 55 }, { 0, 69 }, { -17, 127 }, | |
84 { -13, 102 },{ 0, 82 }, { -7, 74 }, { -21, 107 }, | |
85 { -27, 127 },{ -31, 127 },{ -24, 127 }, { -18, 95 }, | |
86 { -27, 127 },{ -21, 114 },{ -30, 127 }, { -17, 123 }, | |
87 { -12, 115 },{ -16, 122 }, | |
88 | |
89 /* 88 -> 104 */ | |
90 { -11, 115 },{ -12, 63 }, { -2, 68 }, { -15, 84 }, | |
91 { -13, 104 },{ -3, 70 }, { -8, 93 }, { -10, 90 }, | |
92 { -30, 127 },{ -1, 74 }, { -6, 97 }, { -7, 91 }, | |
93 { -20, 127 },{ -4, 56 }, { -5, 82 }, { -7, 76 }, | |
94 { -22, 125 }, | |
95 | |
96 /* 105 -> 135 */ | |
97 { -7, 93 }, { -11, 87 }, { -3, 77 }, { -5, 71 }, | |
98 { -4, 63 }, { -4, 68 }, { -12, 84 }, { -7, 62 }, | |
99 { -7, 65 }, { 8, 61 }, { 5, 56 }, { -2, 66 }, | |
100 { 1, 64 }, { 0, 61 }, { -2, 78 }, { 1, 50 }, | |
101 { 7, 52 }, { 10, 35 }, { 0, 44 }, { 11, 38 }, | |
102 { 1, 45 }, { 0, 46 }, { 5, 44 }, { 31, 17 }, | |
103 { 1, 51 }, { 7, 50 }, { 28, 19 }, { 16, 33 }, | |
104 { 14, 62 }, { -13, 108 },{ -15, 100 }, | |
105 | |
106 /* 136 -> 165 */ | |
107 { -13, 101 },{ -13, 91 }, { -12, 94 }, { -10, 88 }, | |
108 { -16, 84 }, { -10, 86 }, { -7, 83 }, { -13, 87 }, | |
109 { -19, 94 }, { 1, 70 }, { 0, 72 }, { -5, 74 }, | |
110 { 18, 59 }, { -8, 102 }, { -15, 100 }, { 0, 95 }, | |
111 { -4, 75 }, { 2, 72 }, { -11, 75 }, { -3, 71 }, | |
112 { 15, 46 }, { -13, 69 }, { 0, 62 }, { 0, 65 }, | |
113 { 21, 37 }, { -15, 72 }, { 9, 57 }, { 16, 54 }, | |
114 { 0, 62 }, { 12, 72 }, | |
115 | |
116 /* 166 -> 196 */ | |
117 { 24, 0 }, { 15, 9 }, { 8, 25 }, { 13, 18 }, | |
118 { 15, 9 }, { 13, 19 }, { 10, 37 }, { 12, 18 }, | |
119 { 6, 29 }, { 20, 33 }, { 15, 30 }, { 4, 45 }, | |
120 { 1, 58 }, { 0, 62 }, { 7, 61 }, { 12, 38 }, | |
121 { 11, 45 }, { 15, 39 }, { 11, 42 }, { 13, 44 }, | |
122 { 16, 45 }, { 12, 41 }, { 10, 49 }, { 30, 34 }, | |
123 { 18, 42 }, { 10, 55 }, { 17, 51 }, { 17, 46 }, | |
124 { 0, 89 }, { 26, -19 }, { 22, -17 }, | |
125 | |
126 /* 197 -> 226 */ | |
127 { 26, -17 }, { 30, -25 }, { 28, -20 }, { 33, -23 }, | |
128 { 37, -27 }, { 33, -23 }, { 40, -28 }, { 38, -17 }, | |
129 { 33, -11 }, { 40, -15 }, { 41, -6 }, { 38, 1 }, | |
130 { 41, 17 }, { 30, -6 }, { 27, 3 }, { 26, 22 }, | |
131 { 37, -16 }, { 35, -4 }, { 38, -8 }, { 38, -3 }, | |
132 { 37, 3 }, { 38, 5 }, { 42, 0 }, { 35, 16 }, | |
133 { 39, 22 }, { 14, 48 }, { 27, 37 }, { 21, 60 }, | |
134 { 12, 68 }, { 2, 97 }, | |
135 | |
136 /* 227 -> 251 */ | |
137 { -3, 71 }, { -6, 42 }, { -5, 50 }, { -3, 54 }, | |
138 { -2, 62 }, { 0, 58 }, { 1, 63 }, { -2, 72 }, | |
139 { -1, 74 }, { -9, 91 }, { -5, 67 }, { -5, 27 }, | |
140 { -3, 39 }, { -2, 44 }, { 0, 46 }, { -16, 64 }, | |
141 { -8, 68 }, { -10, 78 }, { -6, 77 }, { -10, 86 }, | |
142 { -12, 92 }, { -15, 55 }, { -10, 60 }, { -6, 62 }, | |
143 { -4, 65 }, | |
144 | |
145 /* 252 -> 275 */ | |
146 { -12, 73 }, { -8, 76 }, { -7, 80 }, { -9, 88 }, | |
147 { -17, 110 },{ -11, 97 }, { -20, 84 }, { -11, 79 }, | |
148 { -6, 73 }, { -4, 74 }, { -13, 86 }, { -13, 96 }, | |
149 { -11, 97 }, { -19, 117 },{ -8, 78 }, { -5, 33 }, | |
150 { -4, 48 }, { -2, 53 }, { -3, 62 }, { -13, 71 }, | |
151 { -10, 79 }, { -12, 86 }, { -13, 90 }, { -14, 97 }, | |
152 | |
153 /* 276 a bit special (not used, bypass is used instead) */ | |
154 { 0, 0 }, | |
155 | |
156 /* 277 -> 307 */ | |
157 { -6, 93 }, { -6, 84 }, { -8, 79 }, { 0, 66 }, | |
158 { -1, 71 }, { 0, 62 }, { -2, 60 }, { -2, 59 }, | |
159 { -5, 75 }, { -3, 62 }, { -4, 58 }, { -9, 66 }, | |
160 { -1, 79 }, { 0, 71 }, { 3, 68 }, { 10, 44 }, | |
161 { -7, 62 }, { 15, 36 }, { 14, 40 }, { 16, 27 }, | |
162 { 12, 29 }, { 1, 44 }, { 20, 36 }, { 18, 32 }, | |
163 { 5, 42 }, { 1, 48 }, { 10, 62 }, { 17, 46 }, | |
164 { 9, 64 }, { -12, 104 },{ -11, 97 }, | |
165 | |
166 /* 308 -> 337 */ | |
167 { -16, 96 }, { -7, 88 }, { -8, 85 }, { -7, 85 }, | |
168 { -9, 85 }, { -13, 88 }, { 4, 66 }, { -3, 77 }, | |
169 { -3, 76 }, { -6, 76 }, { 10, 58 }, { -1, 76 }, | |
170 { -1, 83 }, { -7, 99 }, { -14, 95 }, { 2, 95 }, | |
171 { 0, 76 }, { -5, 74 }, { 0, 70 }, { -11, 75 }, | |
172 { 1, 68 }, { 0, 65 }, { -14, 73 }, { 3, 62 }, | |
173 { 4, 62 }, { -1, 68 }, { -13, 75 }, { 11, 55 }, | |
174 { 5, 64 }, { 12, 70 }, | |
175 | |
176 /* 338 -> 368 */ | |
177 { 15, 6 }, { 6, 19 }, { 7, 16 }, { 12, 14 }, | |
178 { 18, 13 }, { 13, 11 }, { 13, 15 }, { 15, 16 }, | |
179 { 12, 23 }, { 13, 23 }, { 15, 20 }, { 14, 26 }, | |
180 { 14, 44 }, { 17, 40 }, { 17, 47 }, { 24, 17 }, | |
181 { 21, 21 }, { 25, 22 }, { 31, 27 }, { 22, 29 }, | |
182 { 19, 35 }, { 14, 50 }, { 10, 57 }, { 7, 63 }, | |
183 { -2, 77 }, { -4, 82 }, { -3, 94 }, { 9, 69 }, | |
184 { -12, 109 },{ 36, -35 }, { 36, -34 }, | |
185 | |
186 /* 369 -> 398 */ | |
187 { 32, -26 }, { 37, -30 }, { 44, -32 }, { 34, -18 }, | |
188 { 34, -15 }, { 40, -15 }, { 33, -7 }, { 35, -5 }, | |
189 { 33, 0 }, { 38, 2 }, { 33, 13 }, { 23, 35 }, | |
190 { 13, 58 }, { 29, -3 }, { 26, 0 }, { 22, 30 }, | |
191 { 31, -7 }, { 35, -15 }, { 34, -3 }, { 34, 3 }, | |
192 { 36, -1 }, { 34, 5 }, { 32, 11 }, { 35, 5 }, | |
193 { 34, 12 }, { 39, 11 }, { 30, 29 }, { 34, 26 }, | |
194 { 29, 39 }, { 19, 66 }, | |
195 | |
196 /* 399 -> 435 */ | |
197 { 31, 21 }, { 31, 31 }, { 25, 50 }, | |
198 { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11, 85 }, | |
199 { -15, 92 }, { -14, 89 }, { -26, 71 }, { -15, 81 }, | |
200 { -14, 80 }, { 0, 68 }, { -14, 70 }, { -24, 56 }, | |
201 { -23, 68 }, { -24, 50 }, { -11, 74 }, { 23, -13 }, | |
202 { 26, -13 }, { 40, -15 }, { 49, -14 }, { 44, 3 }, | |
203 { 45, 6 }, { 44, 34 }, { 33, 54 }, { 19, 82 }, | |
204 { -3, 75 }, { -1, 23 }, { 1, 34 }, { 1, 43 }, | |
205 { 0, 54 }, { -2, 55 }, { 0, 61 }, { 1, 64 }, | |
206 { 0, 68 }, { -9, 92 }, | |
207 | |
208 /* 436 -> 459 */ | |
209 { -14, 106 }, { -13, 97 }, { -15, 90 }, { -12, 90 }, | |
210 { -18, 88 }, { -10, 73 }, { -9, 79 }, { -14, 86 }, | |
211 { -10, 73 }, { -10, 70 }, { -10, 69 }, { -5, 66 }, | |
212 { -9, 64 }, { -5, 58 }, { 2, 59 }, { 21, -10 }, | |
213 { 24, -11 }, { 28, -8 }, { 28, -1 }, { 29, 3 }, | |
214 { 29, 9 }, { 35, 20 }, { 29, 36 }, { 14, 67 } | |
215 }; | |
216 | |
217 static const int8_t cabac_context_init_PB[3][460][2] = | |
218 { | |
219 /* i_cabac_init_idc == 0 */ | |
220 { | |
221 /* 0 - 10 */ | |
222 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 }, | |
223 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 }, | |
224 { -6, 53 }, { -1, 54 }, { 7, 51 }, | |
225 | |
226 /* 11 - 23 */ | |
227 { 23, 33 }, { 23, 2 }, { 21, 0 }, { 1, 9 }, | |
228 { 0, 49 }, { -37, 118 }, { 5, 57 }, { -13, 78 }, | |
229 { -11, 65 }, { 1, 62 }, { 12, 49 }, { -4, 73 }, | |
230 { 17, 50 }, | |
231 | |
232 /* 24 - 39 */ | |
233 { 18, 64 }, { 9, 43 }, { 29, 0 }, { 26, 67 }, | |
234 { 16, 90 }, { 9, 104 }, { -46, 127 }, { -20, 104 }, | |
235 { 1, 67 }, { -13, 78 }, { -11, 65 }, { 1, 62 }, | |
236 { -6, 86 }, { -17, 95 }, { -6, 61 }, { 9, 45 }, | |
237 | |
238 /* 40 - 53 */ | |
239 { -3, 69 }, { -6, 81 }, { -11, 96 }, { 6, 55 }, | |
240 { 7, 67 }, { -5, 86 }, { 2, 88 }, { 0, 58 }, | |
241 { -3, 76 }, { -10, 94 }, { 5, 54 }, { 4, 69 }, | |
242 { -3, 81 }, { 0, 88 }, | |
243 | |
244 /* 54 - 59 */ | |
245 { -7, 67 }, { -5, 74 }, { -4, 74 }, { -5, 80 }, | |
246 { -7, 72 }, { 1, 58 }, | |
247 | |
248 /* 60 - 69 */ | |
249 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
250 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
251 { 13, 41 }, { 3, 62 }, | |
252 | |
253 /* 70 - 87 */ | |
254 { 0, 45 }, { -4, 78 }, { -3, 96 }, { -27, 126 }, | |
255 { -28, 98 }, { -25, 101 }, { -23, 67 }, { -28, 82 }, | |
256 { -20, 94 }, { -16, 83 }, { -22, 110 }, { -21, 91 }, | |
257 { -18, 102 }, { -13, 93 }, { -29, 127 }, { -7, 92 }, | |
258 { -5, 89 }, { -7, 96 }, { -13, 108 }, { -3, 46 }, | |
259 { -1, 65 }, { -1, 57 }, { -9, 93 }, { -3, 74 }, | |
260 { -9, 92 }, { -8, 87 }, { -23, 126 }, { 5, 54 }, | |
261 { 6, 60 }, { 6, 59 }, { 6, 69 }, { -1, 48 }, | |
262 { 0, 68 }, { -4, 69 }, { -8, 88 }, | |
263 | |
264 /* 105 -> 165 */ | |
265 { -2, 85 }, { -6, 78 }, { -1, 75 }, { -7, 77 }, | |
266 { 2, 54 }, { 5, 50 }, { -3, 68 }, { 1, 50 }, | |
267 { 6, 42 }, { -4, 81 }, { 1, 63 }, { -4, 70 }, | |
268 { 0, 67 }, { 2, 57 }, { -2, 76 }, { 11, 35 }, | |
269 { 4, 64 }, { 1, 61 }, { 11, 35 }, { 18, 25 }, | |
270 { 12, 24 }, { 13, 29 }, { 13, 36 }, { -10, 93 }, | |
271 { -7, 73 }, { -2, 73 }, { 13, 46 }, { 9, 49 }, | |
272 { -7, 100 }, { 9, 53 }, { 2, 53 }, { 5, 53 }, | |
273 { -2, 61 }, { 0, 56 }, { 0, 56 }, { -13, 63 }, | |
274 { -5, 60 }, { -1, 62 }, { 4, 57 }, { -6, 69 }, | |
275 { 4, 57 }, { 14, 39 }, { 4, 51 }, { 13, 68 }, | |
276 { 3, 64 }, { 1, 61 }, { 9, 63 }, { 7, 50 }, | |
277 { 16, 39 }, { 5, 44 }, { 4, 52 }, { 11, 48 }, | |
278 { -5, 60 }, { -1, 59 }, { 0, 59 }, { 22, 33 }, | |
279 { 5, 44 }, { 14, 43 }, { -1, 78 }, { 0, 60 }, | |
280 { 9, 69 }, | |
281 | |
282 /* 166 - 226 */ | |
283 { 11, 28 }, { 2, 40 }, { 3, 44 }, { 0, 49 }, | |
284 { 0, 46 }, { 2, 44 }, { 2, 51 }, { 0, 47 }, | |
285 { 4, 39 }, { 2, 62 }, { 6, 46 }, { 0, 54 }, | |
286 { 3, 54 }, { 2, 58 }, { 4, 63 }, { 6, 51 }, | |
287 { 6, 57 }, { 7, 53 }, { 6, 52 }, { 6, 55 }, | |
288 { 11, 45 }, { 14, 36 }, { 8, 53 }, { -1, 82 }, | |
289 { 7, 55 }, { -3, 78 }, { 15, 46 }, { 22, 31 }, | |
290 { -1, 84 }, { 25, 7 }, { 30, -7 }, { 28, 3 }, | |
291 { 28, 4 }, { 32, 0 }, { 34, -1 }, { 30, 6 }, | |
292 { 30, 6 }, { 32, 9 }, { 31, 19 }, { 26, 27 }, | |
293 { 26, 30 }, { 37, 20 }, { 28, 34 }, { 17, 70 }, | |
294 { 1, 67 }, { 5, 59 }, { 9, 67 }, { 16, 30 }, | |
295 { 18, 32 }, { 18, 35 }, { 22, 29 }, { 24, 31 }, | |
296 { 23, 38 }, { 18, 43 }, { 20, 41 }, { 11, 63 }, | |
297 { 9, 59 }, { 9, 64 }, { -1, 94 }, { -2, 89 }, | |
298 { -9, 108 }, | |
299 | |
300 /* 227 - 275 */ | |
301 { -6, 76 }, { -2, 44 }, { 0, 45 }, { 0, 52 }, | |
302 { -3, 64 }, { -2, 59 }, { -4, 70 }, { -4, 75 }, | |
303 { -8, 82 }, { -17, 102 }, { -9, 77 }, { 3, 24 }, | |
304 { 0, 42 }, { 0, 48 }, { 0, 55 }, { -6, 59 }, | |
305 { -7, 71 }, { -12, 83 }, { -11, 87 }, { -30, 119 }, | |
306 { 1, 58 }, { -3, 29 }, { -1, 36 }, { 1, 38 }, | |
307 { 2, 43 }, { -6, 55 }, { 0, 58 }, { 0, 64 }, | |
308 { -3, 74 }, { -10, 90 }, { 0, 70 }, { -4, 29 }, | |
309 { 5, 31 }, { 7, 42 }, { 1, 59 }, { -2, 58 }, | |
310 { -3, 72 }, { -3, 81 }, { -11, 97 }, { 0, 58 }, | |
311 { 8, 5 }, { 10, 14 }, { 14, 18 }, { 13, 27 }, | |
312 { 2, 40 }, { 0, 58 }, { -3, 70 }, { -6, 79 }, | |
313 { -8, 85 }, | |
314 | |
315 /* 276 a bit special (not used, bypass is used instead) */ | |
316 { 0, 0 }, | |
317 | |
318 /* 277 - 337 */ | |
319 { -13, 106 }, { -16, 106 }, { -10, 87 }, { -21, 114 }, | |
320 { -18, 110 }, { -14, 98 }, { -22, 110 }, { -21, 106 }, | |
321 { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 }, | |
322 { -10, 96 }, { -12, 95 }, { -5, 91 }, { -9, 93 }, | |
323 { -22, 94 }, { -5, 86 }, { 9, 67 }, { -4, 80 }, | |
324 { -10, 85 }, { -1, 70 }, { 7, 60 }, { 9, 58 }, | |
325 { 5, 61 }, { 12, 50 }, { 15, 50 }, { 18, 49 }, | |
326 { 17, 54 }, { 10, 41 }, { 7, 46 }, { -1, 51 }, | |
327 { 7, 49 }, { 8, 52 }, { 9, 41 }, { 6, 47 }, | |
328 { 2, 55 }, { 13, 41 }, { 10, 44 }, { 6, 50 }, | |
329 { 5, 53 }, { 13, 49 }, { 4, 63 }, { 6, 64 }, | |
330 { -2, 69 }, { -2, 59 }, { 6, 70 }, { 10, 44 }, | |
331 { 9, 31 }, { 12, 43 }, { 3, 53 }, { 14, 34 }, | |
332 { 10, 38 }, { -3, 52 }, { 13, 40 }, { 17, 32 }, | |
333 { 7, 44 }, { 7, 38 }, { 13, 50 }, { 10, 57 }, | |
334 { 26, 43 }, | |
335 | |
336 /* 338 - 398 */ | |
337 { 14, 11 }, { 11, 14 }, { 9, 11 }, { 18, 11 }, | |
338 { 21, 9 }, { 23, -2 }, { 32, -15 }, { 32, -15 }, | |
339 { 34, -21 }, { 39, -23 }, { 42, -33 }, { 41, -31 }, | |
340 { 46, -28 }, { 38, -12 }, { 21, 29 }, { 45, -24 }, | |
341 { 53, -45 }, { 48, -26 }, { 65, -43 }, { 43, -19 }, | |
342 { 39, -10 }, { 30, 9 }, { 18, 26 }, { 20, 27 }, | |
343 { 0, 57 }, { -14, 82 }, { -5, 75 }, { -19, 97 }, | |
344 { -35, 125 }, { 27, 0 }, { 28, 0 }, { 31, -4 }, | |
345 { 27, 6 }, { 34, 8 }, { 30, 10 }, { 24, 22 }, | |
346 { 33, 19 }, { 22, 32 }, { 26, 31 }, { 21, 41 }, | |
347 { 26, 44 }, { 23, 47 }, { 16, 65 }, { 14, 71 }, | |
348 { 8, 60 }, { 6, 63 }, { 17, 65 }, { 21, 24 }, | |
349 { 23, 20 }, { 26, 23 }, { 27, 32 }, { 28, 23 }, | |
350 { 28, 24 }, { 23, 40 }, { 24, 32 }, { 28, 29 }, | |
351 { 23, 42 }, { 19, 57 }, { 22, 53 }, { 22, 61 }, | |
352 { 11, 86 }, | |
353 | |
354 /* 399 - 435 */ | |
355 { 12, 40 }, { 11, 51 }, { 14, 59 }, | |
356 { -4, 79 }, { -7, 71 }, { -5, 69 }, { -9, 70 }, | |
357 { -8, 66 }, { -10, 68 }, { -19, 73 }, { -12, 69 }, | |
358 { -16, 70 }, { -15, 67 }, { -20, 62 }, { -19, 70 }, | |
359 { -16, 66 }, { -22, 65 }, { -20, 63 }, { 9, -2 }, | |
360 { 26, -9 }, { 33, -9 }, { 39, -7 }, { 41, -2 }, | |
361 { 45, 3 }, { 49, 9 }, { 45, 27 }, { 36, 59 }, | |
362 { -6, 66 }, { -7, 35 }, { -7, 42 }, { -8, 45 }, | |
363 { -5, 48 }, { -12, 56 }, { -6, 60 }, { -5, 62 }, | |
364 { -8, 66 }, { -8, 76 }, | |
365 | |
366 /* 436 - 459 */ | |
367 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 }, | |
368 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 }, | |
369 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 }, | |
370 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 21, -13 }, | |
371 { 33, -14 }, { 39, -7 }, { 46, -2 }, { 51, 2 }, | |
372 { 60, 6 }, { 61, 17 }, { 55, 34 }, { 42, 62 }, | |
373 }, | |
374 | |
375 /* i_cabac_init_idc == 1 */ | |
376 { | |
377 /* 0 - 10 */ | |
378 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 }, | |
379 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 }, | |
380 { -6, 53 }, { -1, 54 }, { 7, 51 }, | |
381 | |
382 /* 11 - 23 */ | |
383 { 22, 25 }, { 34, 0 }, { 16, 0 }, { -2, 9 }, | |
384 { 4, 41 }, { -29, 118 }, { 2, 65 }, { -6, 71 }, | |
385 { -13, 79 }, { 5, 52 }, { 9, 50 }, { -3, 70 }, | |
386 { 10, 54 }, | |
387 | |
388 /* 24 - 39 */ | |
389 { 26, 34 }, { 19, 22 }, { 40, 0 }, { 57, 2 }, | |
390 { 41, 36 }, { 26, 69 }, { -45, 127 }, { -15, 101 }, | |
391 { -4, 76 }, { -6, 71 }, { -13, 79 }, { 5, 52 }, | |
392 { 6, 69 }, { -13, 90 }, { 0, 52 }, { 8, 43 }, | |
393 | |
394 /* 40 - 53 */ | |
395 { -2, 69 },{ -5, 82 },{ -10, 96 },{ 2, 59 }, | |
396 { 2, 75 },{ -3, 87 },{ -3, 100 },{ 1, 56 }, | |
397 { -3, 74 },{ -6, 85 },{ 0, 59 },{ -3, 81 }, | |
398 { -7, 86 },{ -5, 95 }, | |
399 | |
400 /* 54 - 59 */ | |
401 { -1, 66 },{ -1, 77 },{ 1, 70 },{ -2, 86 }, | |
402 { -5, 72 },{ 0, 61 }, | |
403 | |
404 /* 60 - 69 */ | |
405 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
406 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
407 { 13, 41 }, { 3, 62 }, | |
408 | |
409 /* 70 - 104 */ | |
410 { 13, 15 }, { 7, 51 }, { 2, 80 }, { -39, 127 }, | |
411 { -18, 91 }, { -17, 96 }, { -26, 81 }, { -35, 98 }, | |
412 { -24, 102 }, { -23, 97 }, { -27, 119 }, { -24, 99 }, | |
413 { -21, 110 }, { -18, 102 }, { -36, 127 }, { 0, 80 }, | |
414 { -5, 89 }, { -7, 94 }, { -4, 92 }, { 0, 39 }, | |
415 { 0, 65 }, { -15, 84 }, { -35, 127 }, { -2, 73 }, | |
416 { -12, 104 }, { -9, 91 }, { -31, 127 }, { 3, 55 }, | |
417 { 7, 56 }, { 7, 55 }, { 8, 61 }, { -3, 53 }, | |
418 { 0, 68 }, { -7, 74 }, { -9, 88 }, | |
419 | |
420 /* 105 -> 165 */ | |
421 { -13, 103 }, { -13, 91 }, { -9, 89 }, { -14, 92 }, | |
422 { -8, 76 }, { -12, 87 }, { -23, 110 }, { -24, 105 }, | |
423 { -10, 78 }, { -20, 112 }, { -17, 99 }, { -78, 127 }, | |
424 { -70, 127 }, { -50, 127 }, { -46, 127 }, { -4, 66 }, | |
425 { -5, 78 }, { -4, 71 }, { -8, 72 }, { 2, 59 }, | |
426 { -1, 55 }, { -7, 70 }, { -6, 75 }, { -8, 89 }, | |
427 { -34, 119 }, { -3, 75 }, { 32, 20 }, { 30, 22 }, | |
428 { -44, 127 }, { 0, 54 }, { -5, 61 }, { 0, 58 }, | |
429 { -1, 60 }, { -3, 61 }, { -8, 67 }, { -25, 84 }, | |
430 { -14, 74 }, { -5, 65 }, { 5, 52 }, { 2, 57 }, | |
431 { 0, 61 }, { -9, 69 }, { -11, 70 }, { 18, 55 }, | |
432 { -4, 71 }, { 0, 58 }, { 7, 61 }, { 9, 41 }, | |
433 { 18, 25 }, { 9, 32 }, { 5, 43 }, { 9, 47 }, | |
434 { 0, 44 }, { 0, 51 }, { 2, 46 }, { 19, 38 }, | |
435 { -4, 66 }, { 15, 38 }, { 12, 42 }, { 9, 34 }, | |
436 { 0, 89 }, | |
437 | |
438 /* 166 - 226 */ | |
439 { 4, 45 }, { 10, 28 }, { 10, 31 }, { 33, -11 }, | |
440 { 52, -43 }, { 18, 15 }, { 28, 0 }, { 35, -22 }, | |
441 { 38, -25 }, { 34, 0 }, { 39, -18 }, { 32, -12 }, | |
442 { 102, -94 }, { 0, 0 }, { 56, -15 }, { 33, -4 }, | |
443 { 29, 10 }, { 37, -5 }, { 51, -29 }, { 39, -9 }, | |
444 { 52, -34 }, { 69, -58 }, { 67, -63 }, { 44, -5 }, | |
445 { 32, 7 }, { 55, -29 }, { 32, 1 }, { 0, 0 }, | |
446 { 27, 36 }, { 33, -25 }, { 34, -30 }, { 36, -28 }, | |
447 { 38, -28 }, { 38, -27 }, { 34, -18 }, { 35, -16 }, | |
448 { 34, -14 }, { 32, -8 }, { 37, -6 }, { 35, 0 }, | |
449 { 30, 10 }, { 28, 18 }, { 26, 25 }, { 29, 41 }, | |
450 { 0, 75 }, { 2, 72 }, { 8, 77 }, { 14, 35 }, | |
451 { 18, 31 }, { 17, 35 }, { 21, 30 }, { 17, 45 }, | |
452 { 20, 42 }, { 18, 45 }, { 27, 26 }, { 16, 54 }, | |
453 { 7, 66 }, { 16, 56 }, { 11, 73 }, { 10, 67 }, | |
454 { -10, 116 }, | |
455 | |
456 /* 227 - 275 */ | |
457 { -23, 112 }, { -15, 71 }, { -7, 61 }, { 0, 53 }, | |
458 { -5, 66 }, { -11, 77 }, { -9, 80 }, { -9, 84 }, | |
459 { -10, 87 }, { -34, 127 }, { -21, 101 }, { -3, 39 }, | |
460 { -5, 53 }, { -7, 61 }, { -11, 75 }, { -15, 77 }, | |
461 { -17, 91 }, { -25, 107 }, { -25, 111 }, { -28, 122 }, | |
462 { -11, 76 }, { -10, 44 }, { -10, 52 }, { -10, 57 }, | |
463 { -9, 58 }, { -16, 72 }, { -7, 69 }, { -4, 69 }, | |
464 { -5, 74 }, { -9, 86 }, { 2, 66 }, { -9, 34 }, | |
465 { 1, 32 }, { 11, 31 }, { 5, 52 }, { -2, 55 }, | |
466 { -2, 67 }, { 0, 73 }, { -8, 89 }, { 3, 52 }, | |
467 { 7, 4 }, { 10, 8 }, { 17, 8 }, { 16, 19 }, | |
468 { 3, 37 }, { -1, 61 }, { -5, 73 }, { -1, 70 }, | |
469 { -4, 78 }, | |
470 | |
471 /* 276 a bit special (not used, bypass is used instead) */ | |
472 { 0, 0 }, | |
473 | |
474 /* 277 - 337 */ | |
475 { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 }, | |
476 { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 }, | |
477 { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 }, | |
478 { -10, 95 }, { -14, 100 }, { -8, 95 }, { -17, 111 }, | |
479 { -28, 114 }, { -6, 89 }, { -2, 80 }, { -4, 82 }, | |
480 { -9, 85 }, { -8, 81 }, { -1, 72 }, { 5, 64 }, | |
481 { 1, 67 }, { 9, 56 }, { 0, 69 }, { 1, 69 }, | |
482 { 7, 69 }, { -7, 69 }, { -6, 67 }, { -16, 77 }, | |
483 { -2, 64 }, { 2, 61 }, { -6, 67 }, { -3, 64 }, | |
484 { 2, 57 }, { -3, 65 }, { -3, 66 }, { 0, 62 }, | |
485 { 9, 51 }, { -1, 66 }, { -2, 71 }, { -2, 75 }, | |
486 { -1, 70 }, { -9, 72 }, { 14, 60 }, { 16, 37 }, | |
487 { 0, 47 }, { 18, 35 }, { 11, 37 }, { 12, 41 }, | |
488 { 10, 41 }, { 2, 48 }, { 12, 41 }, { 13, 41 }, | |
489 { 0, 59 }, { 3, 50 }, { 19, 40 }, { 3, 66 }, | |
490 { 18, 50 }, | |
491 | |
492 /* 338 - 398 */ | |
493 { 19, -6 }, { 18, -6 }, { 14, 0 }, { 26, -12 }, | |
494 { 31, -16 }, { 33, -25 }, { 33, -22 }, { 37, -28 }, | |
495 { 39, -30 }, { 42, -30 }, { 47, -42 }, { 45, -36 }, | |
496 { 49, -34 }, { 41, -17 }, { 32, 9 }, { 69, -71 }, | |
497 { 63, -63 }, { 66, -64 }, { 77, -74 }, { 54, -39 }, | |
498 { 52, -35 }, { 41, -10 }, { 36, 0 }, { 40, -1 }, | |
499 { 30, 14 }, { 28, 26 }, { 23, 37 }, { 12, 55 }, | |
500 { 11, 65 }, { 37, -33 }, { 39, -36 }, { 40, -37 }, | |
501 { 38, -30 }, { 46, -33 }, { 42, -30 }, { 40, -24 }, | |
502 { 49, -29 }, { 38, -12 }, { 40, -10 }, { 38, -3 }, | |
503 { 46, -5 }, { 31, 20 }, { 29, 30 }, { 25, 44 }, | |
504 { 12, 48 }, { 11, 49 }, { 26, 45 }, { 22, 22 }, | |
505 { 23, 22 }, { 27, 21 }, { 33, 20 }, { 26, 28 }, | |
506 { 30, 24 }, { 27, 34 }, { 18, 42 }, { 25, 39 }, | |
507 { 18, 50 }, { 12, 70 }, { 21, 54 }, { 14, 71 }, | |
508 { 11, 83 }, | |
509 | |
510 /* 399 - 435 */ | |
511 { 25, 32 }, { 21, 49 }, { 21, 54 }, | |
512 { -5, 85 }, { -6, 81 }, { -10, 77 }, { -7, 81 }, | |
513 { -17, 80 }, { -18, 73 }, { -4, 74 }, { -10, 83 }, | |
514 { -9, 71 }, { -9, 67 }, { -1, 61 }, { -8, 66 }, | |
515 { -14, 66 }, { 0, 59 }, { 2, 59 }, { 17, -10 }, | |
516 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 }, | |
517 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 }, | |
518 { -5, 71 }, { 0, 24 }, { -1, 36 }, { -2, 42 }, | |
519 { -2, 52 }, { -9, 57 }, { -6, 63 }, { -4, 65 }, | |
520 { -4, 67 }, { -7, 82 }, | |
521 | |
522 /* 436 - 459 */ | |
523 { -3, 81 }, { -3, 76 }, { -7, 72 }, { -6, 78 }, | |
524 { -12, 72 }, { -14, 68 }, { -3, 70 }, { -6, 76 }, | |
525 { -5, 66 }, { -5, 62 }, { 0, 57 }, { -4, 61 }, | |
526 { -9, 60 }, { 1, 54 }, { 2, 58 }, { 17, -10 }, | |
527 { 32, -13 }, { 42, -9 }, { 49, -5 }, { 53, 0 }, | |
528 { 64, 3 }, { 68, 10 }, { 66, 27 }, { 47, 57 }, | |
529 }, | |
530 | |
531 /* i_cabac_init_idc == 2 */ | |
532 { | |
533 /* 0 - 10 */ | |
534 { 20, -15 }, { 2, 54 }, { 3, 74 }, { 20, -15 }, | |
535 { 2, 54 }, { 3, 74 }, { -28, 127 }, { -23, 104 }, | |
536 { -6, 53 }, { -1, 54 }, { 7, 51 }, | |
537 | |
538 /* 11 - 23 */ | |
539 { 29, 16 }, { 25, 0 }, { 14, 0 }, { -10, 51 }, | |
540 { -3, 62 }, { -27, 99 }, { 26, 16 }, { -4, 85 }, | |
541 { -24, 102 }, { 5, 57 }, { 6, 57 }, { -17, 73 }, | |
542 { 14, 57 }, | |
543 | |
544 /* 24 - 39 */ | |
545 { 20, 40 }, { 20, 10 }, { 29, 0 }, { 54, 0 }, | |
546 { 37, 42 }, { 12, 97 }, { -32, 127 }, { -22, 117 }, | |
547 { -2, 74 }, { -4, 85 }, { -24, 102 }, { 5, 57 }, | |
548 { -6, 93 }, { -14, 88 }, { -6, 44 }, { 4, 55 }, | |
549 | |
550 /* 40 - 53 */ | |
551 { -11, 89 },{ -15, 103 },{ -21, 116 },{ 19, 57 }, | |
552 { 20, 58 },{ 4, 84 },{ 6, 96 },{ 1, 63 }, | |
553 { -5, 85 },{ -13, 106 },{ 5, 63 },{ 6, 75 }, | |
554 { -3, 90 },{ -1, 101 }, | |
555 | |
556 /* 54 - 59 */ | |
557 { 3, 55 },{ -4, 79 },{ -2, 75 },{ -12, 97 }, | |
558 { -7, 50 },{ 1, 60 }, | |
559 | |
560 /* 60 - 69 */ | |
561 { 0, 41 }, { 0, 63 }, { 0, 63 }, { 0, 63 }, | |
562 { -9, 83 }, { 4, 86 }, { 0, 97 }, { -7, 72 }, | |
563 { 13, 41 }, { 3, 62 }, | |
564 | |
565 /* 70 - 104 */ | |
566 { 7, 34 }, { -9, 88 }, { -20, 127 }, { -36, 127 }, | |
567 { -17, 91 }, { -14, 95 }, { -25, 84 }, { -25, 86 }, | |
568 { -12, 89 }, { -17, 91 }, { -31, 127 }, { -14, 76 }, | |
569 { -18, 103 }, { -13, 90 }, { -37, 127 }, { 11, 80 }, | |
570 { 5, 76 }, { 2, 84 }, { 5, 78 }, { -6, 55 }, | |
571 { 4, 61 }, { -14, 83 }, { -37, 127 }, { -5, 79 }, | |
572 { -11, 104 }, { -11, 91 }, { -30, 127 }, { 0, 65 }, | |
573 { -2, 79 }, { 0, 72 }, { -4, 92 }, { -6, 56 }, | |
574 { 3, 68 }, { -8, 71 }, { -13, 98 }, | |
575 | |
576 /* 105 -> 165 */ | |
577 { -4, 86 }, { -12, 88 }, { -5, 82 }, { -3, 72 }, | |
578 { -4, 67 }, { -8, 72 }, { -16, 89 }, { -9, 69 }, | |
579 { -1, 59 }, { 5, 66 }, { 4, 57 }, { -4, 71 }, | |
580 { -2, 71 }, { 2, 58 }, { -1, 74 }, { -4, 44 }, | |
581 { -1, 69 }, { 0, 62 }, { -7, 51 }, { -4, 47 }, | |
582 { -6, 42 }, { -3, 41 }, { -6, 53 }, { 8, 76 }, | |
583 { -9, 78 }, { -11, 83 }, { 9, 52 }, { 0, 67 }, | |
584 { -5, 90 }, { 1, 67 }, { -15, 72 }, { -5, 75 }, | |
585 { -8, 80 }, { -21, 83 }, { -21, 64 }, { -13, 31 }, | |
586 { -25, 64 }, { -29, 94 }, { 9, 75 }, { 17, 63 }, | |
587 { -8, 74 }, { -5, 35 }, { -2, 27 }, { 13, 91 }, | |
588 { 3, 65 }, { -7, 69 }, { 8, 77 }, { -10, 66 }, | |
589 { 3, 62 }, { -3, 68 }, { -20, 81 }, { 0, 30 }, | |
590 { 1, 7 }, { -3, 23 }, { -21, 74 }, { 16, 66 }, | |
591 { -23, 124 }, { 17, 37 }, { 44, -18 }, { 50, -34 }, | |
592 { -22, 127 }, | |
593 | |
594 /* 166 - 226 */ | |
595 { 4, 39 }, { 0, 42 }, { 7, 34 }, { 11, 29 }, | |
596 { 8, 31 }, { 6, 37 }, { 7, 42 }, { 3, 40 }, | |
597 { 8, 33 }, { 13, 43 }, { 13, 36 }, { 4, 47 }, | |
598 { 3, 55 }, { 2, 58 }, { 6, 60 }, { 8, 44 }, | |
599 { 11, 44 }, { 14, 42 }, { 7, 48 }, { 4, 56 }, | |
600 { 4, 52 }, { 13, 37 }, { 9, 49 }, { 19, 58 }, | |
601 { 10, 48 }, { 12, 45 }, { 0, 69 }, { 20, 33 }, | |
602 { 8, 63 }, { 35, -18 }, { 33, -25 }, { 28, -3 }, | |
603 { 24, 10 }, { 27, 0 }, { 34, -14 }, { 52, -44 }, | |
604 { 39, -24 }, { 19, 17 }, { 31, 25 }, { 36, 29 }, | |
605 { 24, 33 }, { 34, 15 }, { 30, 20 }, { 22, 73 }, | |
606 { 20, 34 }, { 19, 31 }, { 27, 44 }, { 19, 16 }, | |
607 { 15, 36 }, { 15, 36 }, { 21, 28 }, { 25, 21 }, | |
608 { 30, 20 }, { 31, 12 }, { 27, 16 }, { 24, 42 }, | |
609 { 0, 93 }, { 14, 56 }, { 15, 57 }, { 26, 38 }, | |
610 { -24, 127 }, | |
611 | |
612 /* 227 - 275 */ | |
613 { -24, 115 }, { -22, 82 }, { -9, 62 }, { 0, 53 }, | |
614 { 0, 59 }, { -14, 85 }, { -13, 89 }, { -13, 94 }, | |
615 { -11, 92 }, { -29, 127 }, { -21, 100 }, { -14, 57 }, | |
616 { -12, 67 }, { -11, 71 }, { -10, 77 }, { -21, 85 }, | |
617 { -16, 88 }, { -23, 104 }, { -15, 98 }, { -37, 127 }, | |
618 { -10, 82 }, { -8, 48 }, { -8, 61 }, { -8, 66 }, | |
619 { -7, 70 }, { -14, 75 }, { -10, 79 }, { -9, 83 }, | |
620 { -12, 92 }, { -18, 108 }, { -4, 79 }, { -22, 69 }, | |
621 { -16, 75 }, { -2, 58 }, { 1, 58 }, { -13, 78 }, | |
622 { -9, 83 }, { -4, 81 }, { -13, 99 }, { -13, 81 }, | |
623 { -6, 38 }, { -13, 62 }, { -6, 58 }, { -2, 59 }, | |
624 { -16, 73 }, { -10, 76 }, { -13, 86 }, { -9, 83 }, | |
625 { -10, 87 }, | |
626 | |
627 /* 276 a bit special (not used, bypass is used instead) */ | |
628 { 0, 0 }, | |
629 | |
630 /* 277 - 337 */ | |
631 { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 }, | |
632 { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 }, | |
633 { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 }, | |
634 { -10, 94 }, { -15, 102 }, { -10, 99 }, { -13, 106 }, | |
635 { -50, 127 }, { -5, 92 }, { 17, 57 }, { -5, 86 }, | |
636 { -13, 94 }, { -12, 91 }, { -2, 77 }, { 0, 71 }, | |
637 { -1, 73 }, { 4, 64 }, { -7, 81 }, { 5, 64 }, | |
638 { 15, 57 }, { 1, 67 }, { 0, 68 }, { -10, 67 }, | |
639 { 1, 68 }, { 0, 77 }, { 2, 64 }, { 0, 68 }, | |
640 { -5, 78 }, { 7, 55 }, { 5, 59 }, { 2, 65 }, | |
641 { 14, 54 }, { 15, 44 }, { 5, 60 }, { 2, 70 }, | |
642 { -2, 76 }, { -18, 86 }, { 12, 70 }, { 5, 64 }, | |
643 { -12, 70 }, { 11, 55 }, { 5, 56 }, { 0, 69 }, | |
644 { 2, 65 }, { -6, 74 }, { 5, 54 }, { 7, 54 }, | |
645 { -6, 76 }, { -11, 82 }, { -2, 77 }, { -2, 77 }, | |
646 { 25, 42 }, | |
647 | |
648 /* 338 - 398 */ | |
649 { 17, -13 }, { 16, -9 }, { 17, -12 }, { 27, -21 }, | |
650 { 37, -30 }, { 41, -40 }, { 42, -41 }, { 48, -47 }, | |
651 { 39, -32 }, { 46, -40 }, { 52, -51 }, { 46, -41 }, | |
652 { 52, -39 }, { 43, -19 }, { 32, 11 }, { 61, -55 }, | |
653 { 56, -46 }, { 62, -50 }, { 81, -67 }, { 45, -20 }, | |
654 { 35, -2 }, { 28, 15 }, { 34, 1 }, { 39, 1 }, | |
655 { 30, 17 }, { 20, 38 }, { 18, 45 }, { 15, 54 }, | |
656 { 0, 79 }, { 36, -16 }, { 37, -14 }, { 37, -17 }, | |
657 { 32, 1 }, { 34, 15 }, { 29, 15 }, { 24, 25 }, | |
658 { 34, 22 }, { 31, 16 }, { 35, 18 }, { 31, 28 }, | |
659 { 33, 41 }, { 36, 28 }, { 27, 47 }, { 21, 62 }, | |
660 { 18, 31 }, { 19, 26 }, { 36, 24 }, { 24, 23 }, | |
661 { 27, 16 }, { 24, 30 }, { 31, 29 }, { 22, 41 }, | |
662 { 22, 42 }, { 16, 60 }, { 15, 52 }, { 14, 60 }, | |
663 { 3, 78 }, { -16, 123 }, { 21, 53 }, { 22, 56 }, | |
664 { 25, 61 }, | |
665 | |
666 /* 399 - 435 */ | |
667 { 21, 33 }, { 19, 50 }, { 17, 61 }, | |
668 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 }, | |
669 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 }, | |
670 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 }, | |
671 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 }, | |
672 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 }, | |
673 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 }, | |
674 { -9, 71 }, { -7, 37 }, { -8, 44 }, { -11, 49 }, | |
675 { -10, 56 }, { -12, 59 }, { -8, 63 }, { -9, 67 }, | |
676 { -6, 68 }, { -10, 79 }, | |
677 | |
678 /* 436 - 459 */ | |
679 { -3, 78 }, { -8, 74 }, { -9, 72 }, { -10, 72 }, | |
680 { -18, 75 }, { -12, 71 }, { -11, 63 }, { -5, 70 }, | |
681 { -17, 75 }, { -14, 72 }, { -16, 67 }, { -8, 53 }, | |
682 { -14, 59 }, { -9, 52 }, { -11, 68 }, { 9, -2 }, | |
683 { 30, -10 }, { 31, -4 }, { 33, -1 }, { 33, 7 }, | |
684 { 31, 12 }, { 37, 23 }, { 31, 38 }, { 20, 64 }, | |
685 } | |
686 }; | |
687 | |
688 void ff_h264_init_cabac_states(H264Context *h) { | |
689 MpegEncContext * const s = &h->s; | |
690 int i; | |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
691 const int8_t (*tab)[2]; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
692 |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
693 if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
694 else tab = cabac_context_init_PB[h->cabac_init_idc]; |
10869 | 695 |
696 /* calculate pre-state */ | |
697 for( i= 0; i < 460; i++ ) { | |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
698 int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127; |
10869 | 699 |
11190
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
700 pre^= pre>>31; |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
701 if(pre > 124) |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
702 pre= 124 + (pre&1); |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
703 |
afc60af2d008
2x faster ff_h264_init_cabac_states(), 4k cpu cycles less.
michael
parents:
11186
diff
changeset
|
704 h->cabac_state[i] = pre; |
10869 | 705 } |
706 } | |
707 | |
708 static int decode_cabac_field_decoding_flag(H264Context *h) { | |
709 MpegEncContext * const s = &h->s; | |
11004 | 710 const long mbb_xy = h->mb_xy - 2L*s->mb_stride; |
10869 | 711 |
11004 | 712 unsigned long ctx = 0; |
10869 | 713 |
11201
4e2d74d7bad8
Speedup decode_cabac_field_decoding_flag() by 9 cpu cycles.
michael
parents:
11191
diff
changeset
|
714 ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num); |
11004 | 715 ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num); |
10869 | 716 |
11004 | 717 return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] ); |
10869 | 718 } |
719 | |
720 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { | |
721 uint8_t *state= &h->cabac_state[ctx_base]; | |
722 int mb_type; | |
723 | |
724 if(intra_slice){ | |
725 int ctx=0; | |
11186
90de754f70d6
2 cpu cycles faster context calculation for decode_cabac_intra_mb_type()
michael
parents:
11185
diff
changeset
|
726 if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) |
10869 | 727 ctx++; |
11186
90de754f70d6
2 cpu cycles faster context calculation for decode_cabac_intra_mb_type()
michael
parents:
11185
diff
changeset
|
728 if( h->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) |
10869 | 729 ctx++; |
730 if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) | |
731 return 0; /* I4x4 */ | |
732 state += 2; | |
733 }else{ | |
10930 | 734 if( get_cabac_noinline( &h->cabac, state ) == 0 ) |
10869 | 735 return 0; /* I4x4 */ |
736 } | |
737 | |
738 if( get_cabac_terminate( &h->cabac ) ) | |
739 return 25; /* PCM */ | |
740 | |
741 mb_type = 1; /* I16x16 */ | |
742 mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */ | |
743 if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */ | |
744 mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] ); | |
745 mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] ); | |
746 mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] ); | |
747 return mb_type; | |
748 } | |
749 | |
750 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) { | |
751 MpegEncContext * const s = &h->s; | |
752 int mba_xy, mbb_xy; | |
753 int ctx = 0; | |
754 | |
755 if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches? | |
756 int mb_xy = mb_x + (mb_y&~1)*s->mb_stride; | |
757 mba_xy = mb_xy - 1; | |
758 if( (mb_y&1) | |
759 && h->slice_table[mba_xy] == h->slice_num | |
760 && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) | |
761 mba_xy += s->mb_stride; | |
762 if( MB_FIELD ){ | |
763 mbb_xy = mb_xy - s->mb_stride; | |
764 if( !(mb_y&1) | |
765 && h->slice_table[mbb_xy] == h->slice_num | |
766 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) | |
767 mbb_xy -= s->mb_stride; | |
768 }else | |
769 mbb_xy = mb_x + (mb_y-1)*s->mb_stride; | |
770 }else{ | |
771 int mb_xy = h->mb_xy; | |
772 mba_xy = mb_xy - 1; | |
773 mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE); | |
774 } | |
775 | |
776 if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )) | |
777 ctx++; | |
778 if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )) | |
779 ctx++; | |
780 | |
781 if( h->slice_type_nos == FF_B_TYPE ) | |
782 ctx += 13; | |
783 return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] ); | |
784 } | |
785 | |
786 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) { | |
787 int mode = 0; | |
788 | |
789 if( get_cabac( &h->cabac, &h->cabac_state[68] ) ) | |
790 return pred_mode; | |
791 | |
792 mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
793 mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
794 mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] ); | |
795 | |
11182 | 796 return mode + ( mode >= pred_mode ); |
10869 | 797 } |
798 | |
799 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { | |
800 const int mba_xy = h->left_mb_xy[0]; | |
801 const int mbb_xy = h->top_mb_xy; | |
802 | |
803 int ctx = 0; | |
804 | |
805 /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ | |
11185 | 806 if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 ) |
10869 | 807 ctx++; |
808 | |
11185 | 809 if( h->top_type && h->chroma_pred_mode_table[mbb_xy] != 0 ) |
10869 | 810 ctx++; |
811 | |
812 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) | |
813 return 0; | |
814 | |
815 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
816 return 1; | |
817 if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 ) | |
818 return 2; | |
819 else | |
820 return 3; | |
821 } | |
822 | |
823 static int decode_cabac_mb_cbp_luma( H264Context *h) { | |
824 int cbp_b, cbp_a, ctx, cbp = 0; | |
825 | |
11166
5bd834bd759b
Remove slice_table checks from decode_cabac_mb_cbp_luma() and set left/top_cbp so
michael
parents:
11004
diff
changeset
|
826 cbp_a = h->left_cbp; |
5bd834bd759b
Remove slice_table checks from decode_cabac_mb_cbp_luma() and set left/top_cbp so
michael
parents:
11004
diff
changeset
|
827 cbp_b = h->top_cbp; |
10869 | 828 |
829 ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04); | |
11544 | 830 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]); |
10869 | 831 ctx = !(cbp & 0x01) + 2 * !(cbp_b & 0x08); |
11544 | 832 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1; |
10869 | 833 ctx = !(cbp_a & 0x08) + 2 * !(cbp & 0x01); |
11544 | 834 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2; |
10869 | 835 ctx = !(cbp & 0x04) + 2 * !(cbp & 0x02); |
11544 | 836 cbp += get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3; |
10869 | 837 return cbp; |
838 } | |
839 static int decode_cabac_mb_cbp_chroma( H264Context *h) { | |
840 int ctx; | |
841 int cbp_a, cbp_b; | |
842 | |
843 cbp_a = (h->left_cbp>>4)&0x03; | |
844 cbp_b = (h-> top_cbp>>4)&0x03; | |
845 | |
846 ctx = 0; | |
847 if( cbp_a > 0 ) ctx++; | |
848 if( cbp_b > 0 ) ctx += 2; | |
849 if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 ) | |
850 return 0; | |
851 | |
852 ctx = 4; | |
853 if( cbp_a == 2 ) ctx++; | |
854 if( cbp_b == 2 ) ctx += 2; | |
855 return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ); | |
856 } | |
857 | |
858 static int decode_cabac_p_mb_sub_type( H264Context *h ) { | |
859 if( get_cabac( &h->cabac, &h->cabac_state[21] ) ) | |
860 return 0; /* 8x8 */ | |
861 if( !get_cabac( &h->cabac, &h->cabac_state[22] ) ) | |
862 return 1; /* 8x4 */ | |
863 if( get_cabac( &h->cabac, &h->cabac_state[23] ) ) | |
864 return 2; /* 4x8 */ | |
865 return 3; /* 4x4 */ | |
866 } | |
867 static int decode_cabac_b_mb_sub_type( H264Context *h ) { | |
868 int type; | |
869 if( !get_cabac( &h->cabac, &h->cabac_state[36] ) ) | |
870 return 0; /* B_Direct_8x8 */ | |
871 if( !get_cabac( &h->cabac, &h->cabac_state[37] ) ) | |
872 return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */ | |
873 type = 3; | |
874 if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) { | |
875 if( get_cabac( &h->cabac, &h->cabac_state[39] ) ) | |
876 return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */ | |
877 type += 4; | |
878 } | |
879 type += 2*get_cabac( &h->cabac, &h->cabac_state[39] ); | |
880 type += get_cabac( &h->cabac, &h->cabac_state[39] ); | |
881 return type; | |
882 } | |
883 | |
884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) { | |
885 int refa = h->ref_cache[list][scan8[n] - 1]; | |
886 int refb = h->ref_cache[list][scan8[n] - 8]; | |
887 int ref = 0; | |
888 int ctx = 0; | |
889 | |
890 if( h->slice_type_nos == FF_B_TYPE) { | |
11167 | 891 if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) ) |
10869 | 892 ctx++; |
11167 | 893 if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) ) |
10869 | 894 ctx += 2; |
895 } else { | |
896 if( refa > 0 ) | |
897 ctx++; | |
898 if( refb > 0 ) | |
899 ctx += 2; | |
900 } | |
901 | |
902 while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) { | |
903 ref++; | |
904 ctx = (ctx>>2)+4; | |
905 if(ref >= 32 /*h->ref_list[list]*/){ | |
906 return -1; | |
907 } | |
908 } | |
909 return ref; | |
910 } | |
911 | |
11275 | 912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) { |
10869 | 913 int mvd; |
914 | |
11305
1a349d669184
Optimize (amvd>2)+(amvd>32), about 1 cpu cycles faster.
michael
parents:
11277
diff
changeset
|
915 if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){ |
1a349d669184
Optimize (amvd>2)+(amvd>32), about 1 cpu cycles faster.
michael
parents:
11277
diff
changeset
|
916 // if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){ |
11275 | 917 *mvda= 0; |
10869 | 918 return 0; |
11275 | 919 } |
10869 | 920 |
921 mvd= 1; | |
11207
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
922 ctxbase+= 3; |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
923 while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) { |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
924 if( mvd < 4 ) |
22ca00416118
Get rid of a local variable, 10 cpu cycles faster.
michael
parents:
11206
diff
changeset
|
925 ctxbase++; |
10869 | 926 mvd++; |
927 } | |
928 | |
929 if( mvd >= 9 ) { | |
930 int k = 3; | |
931 while( get_cabac_bypass( &h->cabac ) ) { | |
932 mvd += 1 << k; | |
933 k++; | |
934 if(k>24){ | |
935 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n"); | |
936 return INT_MIN; | |
937 } | |
938 } | |
939 while( k-- ) { | |
11208 | 940 mvd += get_cabac_bypass( &h->cabac )<<k; |
10869 | 941 } |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
942 *mvda=mvd < 70 ? mvd : 70; |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
943 }else |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
944 *mvda=mvd; |
10869 | 945 return get_cabac_bypass_sign( &h->cabac, -mvd ); |
946 } | |
947 | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
948 #define DECODE_CABAC_MB_MVD( h, list, n )\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
949 {\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
950 int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
951 h->mvd_cache[list][scan8[n] - 8][0];\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
952 int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
953 h->mvd_cache[list][scan8[n] - 8][1];\ |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
954 \ |
11275 | 955 mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\ |
956 my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\ | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
957 } |
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
958 |
10869 | 959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) { |
960 int nza, nzb; | |
961 int ctx = 0; | |
962 | |
963 if( is_dc ) { | |
964 if( cat == 0 ) { | |
965 nza = h->left_cbp&0x100; | |
966 nzb = h-> top_cbp&0x100; | |
967 } else { | |
968 nza = (h->left_cbp>>(6+idx))&0x01; | |
969 nzb = (h-> top_cbp>>(6+idx))&0x01; | |
970 } | |
971 } else { | |
972 assert(cat == 1 || cat == 2 || cat == 4); | |
973 nza = h->non_zero_count_cache[scan8[idx] - 1]; | |
974 nzb = h->non_zero_count_cache[scan8[idx] - 8]; | |
975 } | |
976 | |
977 if( nza > 0 ) | |
978 ctx++; | |
979 | |
980 if( nzb > 0 ) | |
981 ctx += 2; | |
982 | |
983 return ctx + 4 * cat; | |
984 } | |
985 | |
10961
34a65026fa06
Move array specifiers outside DECLARE_ALIGNED() invocations
mru
parents:
10930
diff
changeset
|
986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = { |
10869 | 987 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
988 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | |
989 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, | |
990 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8 | |
991 }; | |
992 | |
993 static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) { | |
994 static const int significant_coeff_flag_offset[2][6] = { | |
995 { 105+0, 105+15, 105+29, 105+44, 105+47, 402 }, | |
996 { 277+0, 277+15, 277+29, 277+44, 277+47, 436 } | |
997 }; | |
998 static const int last_coeff_flag_offset[2][6] = { | |
999 { 166+0, 166+15, 166+29, 166+44, 166+47, 417 }, | |
1000 { 338+0, 338+15, 338+29, 338+44, 338+47, 451 } | |
1001 }; | |
1002 static const int coeff_abs_level_m1_offset[6] = { | |
1003 227+0, 227+10, 227+20, 227+30, 227+39, 426 | |
1004 }; | |
1005 static const uint8_t significant_coeff_flag_offset_8x8[2][63] = { | |
1006 { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, | |
1007 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7, | |
1008 7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11, | |
1009 12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 }, | |
1010 { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, | |
1011 6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11, | |
1012 9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9, | |
1013 9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 } | |
1014 }; | |
1015 /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0). | |
1016 * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter). | |
1017 * map node ctx => cabac ctx for level=1 */ | |
1018 static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 }; | |
1019 /* map node ctx => cabac ctx for level>1 */ | |
1020 static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 }; | |
1021 static const uint8_t coeff_abs_level_transition[2][8] = { | |
1022 /* update node ctx after decoding a level=1 */ | |
1023 { 1, 2, 3, 3, 4, 5, 6, 7 }, | |
1024 /* update node ctx after decoding a level>1 */ | |
1025 { 4, 4, 4, 4, 5, 6, 7, 7 } | |
1026 }; | |
1027 | |
1028 int index[64]; | |
1029 | |
1030 int av_unused last; | |
1031 int coeff_count = 0; | |
1032 int node_ctx = 0; | |
1033 | |
1034 uint8_t *significant_coeff_ctx_base; | |
1035 uint8_t *last_coeff_ctx_base; | |
1036 uint8_t *abs_level_m1_ctx_base; | |
1037 | |
1038 #if !ARCH_X86 | |
1039 #define CABAC_ON_STACK | |
1040 #endif | |
1041 #ifdef CABAC_ON_STACK | |
1042 #define CC &cc | |
1043 CABACContext cc; | |
1044 cc.range = h->cabac.range; | |
1045 cc.low = h->cabac.low; | |
1046 cc.bytestream= h->cabac.bytestream; | |
1047 #else | |
1048 #define CC &h->cabac | |
1049 #endif | |
1050 | |
1051 | |
1052 /* cat: 0-> DC 16x16 n = 0 | |
1053 * 1-> AC 16x16 n = luma4x4idx | |
1054 * 2-> Luma4x4 n = luma4x4idx | |
1055 * 3-> DC Chroma n = iCbCr | |
1056 * 4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx | |
1057 * 5-> Luma8x8 n = 4 * luma8x8idx | |
1058 */ | |
1059 | |
1060 /* read coded block flag */ | |
1061 if( is_dc || cat != 5 ) { | |
1062 if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) { | |
1063 if( !is_dc ) | |
1064 h->non_zero_count_cache[scan8[n]] = 0; | |
1065 | |
1066 #ifdef CABAC_ON_STACK | |
1067 h->cabac.range = cc.range ; | |
1068 h->cabac.low = cc.low ; | |
1069 h->cabac.bytestream= cc.bytestream; | |
1070 #endif | |
1071 return; | |
1072 } | |
1073 } | |
1074 | |
1075 significant_coeff_ctx_base = h->cabac_state | |
1076 + significant_coeff_flag_offset[MB_FIELD][cat]; | |
1077 last_coeff_ctx_base = h->cabac_state | |
1078 + last_coeff_flag_offset[MB_FIELD][cat]; | |
1079 abs_level_m1_ctx_base = h->cabac_state | |
1080 + coeff_abs_level_m1_offset[cat]; | |
1081 | |
1082 if( !is_dc && cat == 5 ) { | |
1083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \ | |
1084 for(last= 0; last < coefs; last++) { \ | |
1085 uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \ | |
1086 if( get_cabac( CC, sig_ctx )) { \ | |
1087 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \ | |
1088 index[coeff_count++] = last; \ | |
1089 if( get_cabac( CC, last_ctx ) ) { \ | |
1090 last= max_coeff; \ | |
1091 break; \ | |
1092 } \ | |
1093 } \ | |
1094 }\ | |
1095 if( last == max_coeff -1 ) {\ | |
1096 index[coeff_count++] = last;\ | |
1097 } | |
1098 const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD]; | |
1099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS) | |
1100 coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off); | |
1101 } else { | |
1102 coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index); | |
1103 #else | |
1104 DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] ); | |
1105 } else { | |
1106 DECODE_SIGNIFICANCE( max_coeff - 1, last, last ); | |
1107 #endif | |
1108 } | |
1109 assert(coeff_count > 0); | |
1110 | |
1111 if( is_dc ) { | |
1112 if( cat == 0 ) | |
1113 h->cbp_table[h->mb_xy] |= 0x100; | |
1114 else | |
1115 h->cbp_table[h->mb_xy] |= 0x40 << n; | |
1116 } else { | |
1117 if( cat == 5 ) | |
1118 fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1); | |
1119 else { | |
1120 assert( cat == 1 || cat == 2 || cat == 4 ); | |
1121 h->non_zero_count_cache[scan8[n]] = coeff_count; | |
1122 } | |
1123 } | |
1124 | |
1125 do { | |
1126 uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1127 | |
1128 int j= scantable[index[--coeff_count]]; | |
1129 | |
1130 if( get_cabac( CC, ctx ) == 0 ) { | |
1131 node_ctx = coeff_abs_level_transition[0][node_ctx]; | |
1132 if( is_dc ) { | |
1133 block[j] = get_cabac_bypass_sign( CC, -1); | |
1134 }else{ | |
1135 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; | |
1136 } | |
1137 } else { | |
1138 int coeff_abs = 2; | |
1139 ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; | |
1140 node_ctx = coeff_abs_level_transition[1][node_ctx]; | |
1141 | |
1142 while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { | |
1143 coeff_abs++; | |
1144 } | |
1145 | |
1146 if( coeff_abs >= 15 ) { | |
1147 int j = 0; | |
1148 while( get_cabac_bypass( CC ) ) { | |
1149 j++; | |
1150 } | |
1151 | |
1152 coeff_abs=1; | |
1153 while( j-- ) { | |
1154 coeff_abs += coeff_abs + get_cabac_bypass( CC ); | |
1155 } | |
1156 coeff_abs+= 14; | |
1157 } | |
1158 | |
1159 if( is_dc ) { | |
1160 block[j] = get_cabac_bypass_sign( CC, -coeff_abs ); | |
1161 }else{ | |
1162 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6; | |
1163 } | |
1164 } | |
1165 } while( coeff_count ); | |
1166 #ifdef CABAC_ON_STACK | |
1167 h->cabac.range = cc.range ; | |
1168 h->cabac.low = cc.low ; | |
1169 h->cabac.bytestream= cc.bytestream; | |
1170 #endif | |
1171 | |
1172 } | |
1173 | |
11542 | 1174 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) { |
1175 decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1); | |
10869 | 1176 } |
1177 | |
1178 static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) { | |
1179 decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0); | |
1180 } | |
1181 | |
1182 /** | |
1183 * decodes a macroblock | |
11556 | 1184 * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed |
10869 | 1185 */ |
1186 int ff_h264_decode_mb_cabac(H264Context *h) { | |
1187 MpegEncContext * const s = &h->s; | |
1188 int mb_xy; | |
1189 int mb_type, partition_count, cbp = 0; | |
1190 int dct8x8_allowed= h->pps.transform_8x8_mode; | |
1191 | |
1192 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
1193 | |
1194 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); | |
1195 if( h->slice_type_nos != FF_I_TYPE ) { | |
1196 int skip; | |
1197 /* a skipped mb needs the aff flag from the following mb */ | |
1198 if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped ) | |
1199 skip = h->next_mb_skipped; | |
1200 else | |
1201 skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y ); | |
1202 /* read skip flags */ | |
1203 if( skip ) { | |
1204 if( FRAME_MBAFF && (s->mb_y&1)==0 ){ | |
1205 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP; | |
1206 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 ); | |
1207 if(!h->next_mb_skipped) | |
1208 h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1209 } | |
1210 | |
1211 decode_mb_skip(h); | |
1212 | |
1213 h->cbp_table[mb_xy] = 0; | |
1214 h->chroma_pred_mode_table[mb_xy] = 0; | |
1215 h->last_qscale_diff = 0; | |
1216 | |
1217 return 0; | |
1218 | |
1219 } | |
1220 } | |
1221 if(FRAME_MBAFF){ | |
1222 if( (s->mb_y&1) == 0 ) | |
1223 h->mb_mbaff = | |
1224 h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h); | |
1225 } | |
1226 | |
1227 h->prev_mb_skipped = 0; | |
1228 | |
11184
cc70f8c44019
Drop compute_mb_neighbors() and move fill_decode_neighbors() up to take its
michael
parents:
11183
diff
changeset
|
1229 fill_decode_neighbors(h, -(MB_FIELD)); |
10869 | 1230 |
1231 if( h->slice_type_nos == FF_B_TYPE ) { | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1232 int ctx = 0; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1233 assert(h->slice_type_nos == FF_B_TYPE); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1234 |
11185 | 1235 if( !IS_DIRECT( h->left_type[0]-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1236 ctx++; |
11185 | 1237 if( !IS_DIRECT( h->top_type-1 ) ) |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1238 ctx++; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1239 |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1240 if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1241 mb_type= 0; /* B_Direct_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1242 }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) { |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1243 mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1244 }else{ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1245 int bits; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1246 bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3; |
11544 | 1247 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2; |
1248 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1; | |
1249 bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); | |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1250 if( bits < 8 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1251 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1252 }else if( bits == 13 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1253 mb_type= decode_cabac_intra_mb_type(h, 32, 0); |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1254 goto decode_intra_mb; |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1255 }else if( bits == 14 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1256 mb_type= 11; /* B_L1_L0_8x16 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1257 }else if( bits == 15 ){ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1258 mb_type= 22; /* B_8x8 */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1259 }else{ |
11544 | 1260 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); |
11181
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1261 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */ |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1262 } |
63f55748173c
Merge decode_cabac_mb_type_b() into calling code.
michael
parents:
11172
diff
changeset
|
1263 } |
10869 | 1264 partition_count= b_mb_type_info[mb_type].partition_count; |
1265 mb_type= b_mb_type_info[mb_type].type; | |
1266 } else if( h->slice_type_nos == FF_P_TYPE ) { | |
1267 if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) { | |
1268 /* P-type */ | |
1269 if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) { | |
1270 /* P_L0_D16x16, P_8x8 */ | |
1271 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] ); | |
1272 } else { | |
1273 /* P_L0_D8x16, P_L0_D16x8 */ | |
1274 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] ); | |
1275 } | |
1276 partition_count= p_mb_type_info[mb_type].partition_count; | |
1277 mb_type= p_mb_type_info[mb_type].type; | |
1278 } else { | |
1279 mb_type= decode_cabac_intra_mb_type(h, 17, 0); | |
1280 goto decode_intra_mb; | |
1281 } | |
1282 } else { | |
1283 mb_type= decode_cabac_intra_mb_type(h, 3, 1); | |
1284 if(h->slice_type == FF_SI_TYPE && mb_type) | |
1285 mb_type--; | |
1286 assert(h->slice_type_nos == FF_I_TYPE); | |
1287 decode_intra_mb: | |
1288 partition_count = 0; | |
1289 cbp= i_mb_type_info[mb_type].cbp; | |
1290 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; | |
1291 mb_type= i_mb_type_info[mb_type].type; | |
1292 } | |
1293 if(MB_FIELD) | |
1294 mb_type |= MB_TYPE_INTERLACED; | |
1295 | |
1296 h->slice_table[ mb_xy ]= h->slice_num; | |
1297 | |
1298 if(IS_INTRA_PCM(mb_type)) { | |
1299 const uint8_t *ptr; | |
1300 | |
1301 // We assume these blocks are very rare so we do not optimize it. | |
1302 // FIXME The two following lines get the bitstream position in the cabac | |
1303 // decode, I think it should be done by a function in cabac.h (or cabac.c). | |
1304 ptr= h->cabac.bytestream; | |
1305 if(h->cabac.low&0x1) ptr--; | |
1306 if(CABAC_BITS==16){ | |
1307 if(h->cabac.low&0x1FF) ptr--; | |
1308 } | |
1309 | |
1310 // The pixels are stored in the same order as levels in h->mb array. | |
1311 memcpy(h->mb, ptr, 256); ptr+=256; | |
1312 if(CHROMA){ | |
1313 memcpy(h->mb+128, ptr, 128); ptr+=128; | |
1314 } | |
1315 | |
1316 ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr); | |
1317 | |
1318 // All blocks are present | |
1319 h->cbp_table[mb_xy] = 0x1ef; | |
1320 h->chroma_pred_mode_table[mb_xy] = 0; | |
1321 // In deblocking, the quantizer is 0 | |
1322 s->current_picture.qscale_table[mb_xy]= 0; | |
1323 // All coeffs are present | |
10906 | 1324 memset(h->non_zero_count[mb_xy], 16, 32); |
10869 | 1325 s->current_picture.mb_type[mb_xy]= mb_type; |
1326 h->last_qscale_diff = 0; | |
1327 return 0; | |
1328 } | |
1329 | |
1330 if(MB_MBAFF){ | |
1331 h->ref_count[0] <<= 1; | |
1332 h->ref_count[1] <<= 1; | |
1333 } | |
1334 | |
10907 | 1335 fill_decode_caches(h, mb_type); |
10869 | 1336 |
1337 if( IS_INTRA( mb_type ) ) { | |
1338 int i, pred_mode; | |
1339 if( IS_INTRA4x4( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1340 if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) { |
10869 | 1341 mb_type |= MB_TYPE_8x8DCT; |
1342 for( i = 0; i < 16; i+=4 ) { | |
1343 int pred = pred_intra_mode( h, i ); | |
1344 int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1345 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); | |
1346 } | |
1347 } else { | |
1348 for( i = 0; i < 16; i++ ) { | |
1349 int pred = pred_intra_mode( h, i ); | |
1350 h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred ); | |
1351 | |
1352 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] ); | |
1353 } | |
1354 } | |
1355 ff_h264_write_back_intra_pred_mode(h); | |
1356 if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1; | |
1357 } else { | |
1358 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode ); | |
1359 if( h->intra16x16_pred_mode < 0 ) return -1; | |
1360 } | |
1361 if(CHROMA){ | |
1362 h->chroma_pred_mode_table[mb_xy] = | |
1363 pred_mode = decode_cabac_mb_chroma_pre_mode( h ); | |
1364 | |
1365 pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode ); | |
1366 if( pred_mode < 0 ) return -1; | |
1367 h->chroma_pred_mode= pred_mode; | |
1368 } | |
1369 } else if( partition_count == 4 ) { | |
1370 int i, j, sub_partition_count[4], list, ref[2][4]; | |
1371 | |
1372 if( h->slice_type_nos == FF_B_TYPE ) { | |
1373 for( i = 0; i < 4; i++ ) { | |
1374 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h ); | |
1375 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1376 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1377 } | |
1378 if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] | | |
1379 h->sub_mb_type[2] | h->sub_mb_type[3]) ) { | |
1380 ff_h264_pred_direct_motion(h, &mb_type); | |
1381 h->ref_cache[0][scan8[4]] = | |
1382 h->ref_cache[1][scan8[4]] = | |
1383 h->ref_cache[0][scan8[12]] = | |
1384 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; | |
1385 for( i = 0; i < 4; i++ ) | |
11168
a820571a6712
Set sub_mb_type in direct_cache instead of just the direct flag.
michael
parents:
11167
diff
changeset
|
1386 fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 ); |
10869 | 1387 } |
1388 } else { | |
1389 for( i = 0; i < 4; i++ ) { | |
1390 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h ); | |
1391 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; | |
1392 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; | |
1393 } | |
1394 } | |
1395 | |
1396 for( list = 0; list < h->list_count; list++ ) { | |
1397 for( i = 0; i < 4; i++ ) { | |
1398 if(IS_DIRECT(h->sub_mb_type[i])) continue; | |
1399 if(IS_DIR(h->sub_mb_type[i], 0, list)){ | |
1400 if( h->ref_count[list] > 1 ){ | |
1401 ref[list][i] = decode_cabac_mb_ref( h, list, 4*i ); | |
1402 if(ref[list][i] >= (unsigned)h->ref_count[list]){ | |
1403 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]); | |
1404 return -1; | |
1405 } | |
1406 }else | |
1407 ref[list][i] = 0; | |
1408 } else { | |
1409 ref[list][i] = -1; | |
1410 } | |
1411 h->ref_cache[list][ scan8[4*i]+1 ]= | |
1412 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; | |
1413 } | |
1414 } | |
1415 | |
1416 if(dct8x8_allowed) | |
1417 dct8x8_allowed = get_dct8x8_allowed(h); | |
1418 | |
1419 for(list=0; list<h->list_count; list++){ | |
1420 for(i=0; i<4; i++){ | |
1421 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]; | |
1422 if(IS_DIRECT(h->sub_mb_type[i])){ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1423 fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2); |
10869 | 1424 continue; |
1425 } | |
1426 | |
1427 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){ | |
1428 const int sub_mb_type= h->sub_mb_type[i]; | |
1429 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; | |
1430 for(j=0; j<sub_partition_count[i]; j++){ | |
1431 int mpx, mpy; | |
1432 int mx, my; | |
1433 const int index= 4*i + block_width*j; | |
1434 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1435 uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; |
11275 | 1436 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1437 DECODE_CABAC_MB_MVD( h, list, index) |
10869 | 1438 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1439 | |
1440 if(IS_SUB_8X8(sub_mb_type)){ | |
1441 mv_cache[ 1 ][0]= | |
1442 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; | |
1443 mv_cache[ 1 ][1]= | |
1444 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; | |
1445 | |
1446 mvd_cache[ 1 ][0]= | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1447 mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx; |
10869 | 1448 mvd_cache[ 1 ][1]= |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1449 mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy; |
10869 | 1450 }else if(IS_SUB_8X4(sub_mb_type)){ |
1451 mv_cache[ 1 ][0]= mx; | |
1452 mv_cache[ 1 ][1]= my; | |
1453 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1454 mvd_cache[ 1 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1455 mvd_cache[ 1 ][1]= mpy; |
10869 | 1456 }else if(IS_SUB_4X8(sub_mb_type)){ |
1457 mv_cache[ 8 ][0]= mx; | |
1458 mv_cache[ 8 ][1]= my; | |
1459 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1460 mvd_cache[ 8 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1461 mvd_cache[ 8 ][1]= mpy; |
10869 | 1462 } |
1463 mv_cache[ 0 ][0]= mx; | |
1464 mv_cache[ 0 ][1]= my; | |
1465 | |
11206
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1466 mvd_cache[ 0 ][0]= mpx; |
cb29d50bf6d4
Move abs() from decode_cabac_mb_mvd() to the code that writes mvd_cache.
michael
parents:
11201
diff
changeset
|
1467 mvd_cache[ 0 ][1]= mpy; |
10869 | 1468 } |
1469 }else{ | |
11271
bf3436efe037
Replace ad-hoc fill rectangle by fill_rectangle().
michael
parents:
11208
diff
changeset
|
1470 fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4); |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1471 fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2); |
10869 | 1472 } |
1473 } | |
1474 } | |
1475 } else if( IS_DIRECT(mb_type) ) { | |
1476 ff_h264_pred_direct_motion(h, &mb_type); | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1477 fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2); |
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1478 fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2); |
10869 | 1479 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; |
1480 } else { | |
11275 | 1481 int list, i; |
10869 | 1482 if(IS_16X16(mb_type)){ |
1483 for(list=0; list<h->list_count; list++){ | |
1484 if(IS_DIR(mb_type, 0, list)){ | |
1485 int ref; | |
1486 if(h->ref_count[list] > 1){ | |
1487 ref= decode_cabac_mb_ref(h, list, 0); | |
1488 if(ref >= (unsigned)h->ref_count[list]){ | |
1489 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1490 return -1; | |
1491 } | |
1492 }else | |
1493 ref=0; | |
1494 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1); | |
11325
c4c8c8c426eb
Remove some unneeded fill_rectangle() for 16x16 blocks.
michael
parents:
11305
diff
changeset
|
1495 } |
10869 | 1496 } |
1497 for(list=0; list<h->list_count; list++){ | |
1498 if(IS_DIR(mb_type, 0, list)){ | |
11275 | 1499 int mx,my,mpx,mpy; |
1500 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1501 DECODE_CABAC_MB_MVD( h, list, 0) |
10869 | 1502 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1503 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1504 fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1505 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); |
11325
c4c8c8c426eb
Remove some unneeded fill_rectangle() for 16x16 blocks.
michael
parents:
11305
diff
changeset
|
1506 } |
10869 | 1507 } |
1508 } | |
1509 else if(IS_16X8(mb_type)){ | |
1510 for(list=0; list<h->list_count; list++){ | |
1511 for(i=0; i<2; i++){ | |
1512 if(IS_DIR(mb_type, i, list)){ | |
1513 int ref; | |
1514 if(h->ref_count[list] > 1){ | |
1515 ref= decode_cabac_mb_ref( h, list, 8*i ); | |
1516 if(ref >= (unsigned)h->ref_count[list]){ | |
1517 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1518 return -1; | |
1519 } | |
1520 }else | |
1521 ref=0; | |
1522 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1); | |
1523 }else | |
1524 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1); | |
1525 } | |
1526 } | |
1527 for(list=0; list<h->list_count; list++){ | |
1528 for(i=0; i<2; i++){ | |
1529 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1530 int mx,my,mpx,mpy; |
1531 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1532 DECODE_CABAC_MB_MVD( h, list, 8*i) |
10869 | 1533 tprintf(s->avctx, "final mv:%d %d\n", mx, my); |
1534 | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1535 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2); |
10869 | 1536 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4); |
1537 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1538 fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2); |
10869 | 1539 fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4); |
1540 } | |
1541 } | |
1542 } | |
1543 }else{ | |
1544 assert(IS_8X16(mb_type)); | |
1545 for(list=0; list<h->list_count; list++){ | |
1546 for(i=0; i<2; i++){ | |
1547 if(IS_DIR(mb_type, i, list)){ //FIXME optimize | |
1548 int ref; | |
1549 if(h->ref_count[list] > 1){ | |
1550 ref= decode_cabac_mb_ref( h, list, 4*i ); | |
1551 if(ref >= (unsigned)h->ref_count[list]){ | |
1552 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]); | |
1553 return -1; | |
1554 } | |
1555 }else | |
1556 ref=0; | |
1557 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1); | |
1558 }else | |
1559 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1); | |
1560 } | |
1561 } | |
1562 for(list=0; list<h->list_count; list++){ | |
1563 for(i=0; i<2; i++){ | |
1564 if(IS_DIR(mb_type, i, list)){ | |
11275 | 1565 int mx,my,mpx,mpy; |
1566 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); | |
11273
a2cb557201bb
Factorize common code from the top of decode_cabac_mb_mvd()
michael
parents:
11272
diff
changeset
|
1567 DECODE_CABAC_MB_MVD( h, list, 4*i) |
10869 | 1568 |
1569 tprintf(s->avctx, "final mv:%d %d\n", mx, my); | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1570 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2); |
10869 | 1571 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4); |
1572 }else{ | |
11277
c12d6c6c027e
Change mvd_cache & mvd_table to 8bit, this is overall a bit faster
michael
parents:
11275
diff
changeset
|
1573 fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2); |
10869 | 1574 fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4); |
1575 } | |
1576 } | |
1577 } | |
1578 } | |
1579 } | |
1580 | |
1581 if( IS_INTER( mb_type ) ) { | |
1582 h->chroma_pred_mode_table[mb_xy] = 0; | |
1583 write_back_motion( h, mb_type ); | |
1584 } | |
1585 | |
1586 if( !IS_INTRA16x16( mb_type ) ) { | |
1587 cbp = decode_cabac_mb_cbp_luma( h ); | |
1588 if(CHROMA) | |
1589 cbp |= decode_cabac_mb_cbp_chroma( h ) << 4; | |
1590 } | |
1591 | |
1592 h->cbp_table[mb_xy] = h->cbp = cbp; | |
1593 | |
1594 if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) { | |
11172
458393d0db0a
Merge the single line function decode_cabac_mb_transform_size()
michael
parents:
11171
diff
changeset
|
1595 mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ); |
10869 | 1596 } |
1597 s->current_picture.mb_type[mb_xy]= mb_type; | |
1598 | |
1599 if( cbp || IS_INTRA16x16( mb_type ) ) { | |
1600 const uint8_t *scan, *scan8x8, *dc_scan; | |
1601 const uint32_t *qmul; | |
1602 | |
1603 if(IS_INTERLACED(mb_type)){ | |
1604 scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0; | |
1605 scan= s->qscale ? h->field_scan : h->field_scan_q0; | |
1606 dc_scan= luma_dc_field_scan; | |
1607 }else{ | |
1608 scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0; | |
1609 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; | |
1610 dc_scan= luma_dc_zigzag_scan; | |
1611 } | |
1612 | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1613 // decode_cabac_mb_dqp |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1614 if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){ |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1615 int val = 1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1616 int ctx= 2; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1617 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1618 while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) { |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1619 ctx= 3; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1620 val++; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1621 if(val > 102){ //prevent infinite loop |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1622 av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1623 return -1; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1624 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1625 } |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1626 |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1627 if( val&0x01 ) |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1628 val= (val + 1)>>1 ; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1629 else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1630 val= -((val + 1)>>1); |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1631 h->last_qscale_diff = val; |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1632 s->qscale += val; |
11171 | 1633 if(((unsigned)s->qscale) > 51){ |
1634 if(s->qscale<0) s->qscale+= 52; | |
1635 else s->qscale-= 52; | |
1636 } | |
1637 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); | |
1638 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); | |
11170
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1639 }else |
d092ec99cb59
Merge decode_cabac_mb_dqp() with surronding code.
michael
parents:
11168
diff
changeset
|
1640 h->last_qscale_diff=0; |
10869 | 1641 |
1642 if( IS_INTRA16x16( mb_type ) ) { | |
1643 int i; | |
1644 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" ); | |
11542 | 1645 decode_cabac_residual_dc( h, h->mb, 0, 0, dc_scan, 16); |
10869 | 1646 |
1647 if( cbp&15 ) { | |
1648 qmul = h->dequant4_coeff[0][s->qscale]; | |
1649 for( i = 0; i < 16; i++ ) { | |
1650 //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i ); | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1651 decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15); |
10869 | 1652 } |
1653 } else { | |
1654 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); | |
1655 } | |
1656 } else { | |
1657 int i8x8, i4x4; | |
1658 for( i8x8 = 0; i8x8 < 4; i8x8++ ) { | |
1659 if( cbp & (1<<i8x8) ) { | |
1660 if( IS_8x8DCT(mb_type) ) { | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1661 decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8, |
10869 | 1662 scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64); |
1663 } else { | |
1664 qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale]; | |
1665 for( i4x4 = 0; i4x4 < 4; i4x4++ ) { | |
1666 const int index = 4*i8x8 + i4x4; | |
1667 //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index ); | |
1668 //START_TIMER | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1669 decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16); |
10869 | 1670 //STOP_TIMER("decode_residual") |
1671 } | |
1672 } | |
1673 } else { | |
1674 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; | |
1675 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; | |
1676 } | |
1677 } | |
1678 } | |
1679 | |
1680 if( cbp&0x30 ){ | |
1681 int c; | |
1682 for( c = 0; c < 2; c++ ) { | |
1683 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c ); | |
11542 | 1684 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, 4); |
10869 | 1685 } |
1686 } | |
1687 | |
1688 if( cbp&0x20 ) { | |
1689 int c, i; | |
1690 for( c = 0; c < 2; c++ ) { | |
1691 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]]; | |
1692 for( i = 0; i < 4; i++ ) { | |
1693 const int index = 16 + 4 * c + i; | |
1694 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 ); | |
11541
a3790cd1c9ca
h264: Simplify decode_cabac_residual() specialization
astrange
parents:
11325
diff
changeset
|
1695 decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15); |
10869 | 1696 } |
1697 } | |
1698 } else { | |
1699 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1700 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1701 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1702 } | |
1703 } else { | |
1704 uint8_t * const nnz= &h->non_zero_count_cache[0]; | |
1705 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); | |
1706 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = | |
1707 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; | |
1708 h->last_qscale_diff = 0; | |
1709 } | |
1710 | |
1711 s->current_picture.qscale_table[mb_xy]= s->qscale; | |
1712 write_back_non_zero_count(h); | |
1713 | |
1714 if(MB_MBAFF){ | |
1715 h->ref_count[0] >>= 1; | |
1716 h->ref_count[1] >>= 1; | |
1717 } | |
1718 | |
1719 return 0; | |
1720 } |