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