Optimize (amvd>2)+(amvd>32), about 1 cpu cycles faster.
[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     const int8_t (*tab)[2];
692
693     if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
694     else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
695
696     /* calculate pre-state */
697     for( i= 0; i < 460; i++ ) {
698         int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
699
700         pre^= pre>>31;
701         if(pre > 124)
702             pre= 124 + (pre&1);
703
704         h->cabac_state[i] =  pre;
705     }
706 }
707
708 static int decode_cabac_field_decoding_flag(H264Context *h) {
709     MpegEncContext * const s = &h->s;
710     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
711
712     unsigned long ctx = 0;
713
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);
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         int ctx=0;
726         if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
727             ctx++;
728         if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
729             ctx++;
730         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
731             return 0;   /* I4x4 */
732         state += 2;
733     }else{
734         if( get_cabac_noinline( &h->cabac, state ) == 0 )
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
796     return mode + ( mode >= pred_mode );
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 */
806     if( h->left_type[0] && h->chroma_pred_mode_table[mba_xy] != 0 )
807         ctx++;
808
809     if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
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
826     cbp_a = h->left_cbp;
827     cbp_b = h->top_cbp;
828
829     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
830     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
831     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
832     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
833     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
834     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
835     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
836     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
837     return cbp;
838 }
839 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
840     int ctx;
841     int cbp_a, cbp_b;
842
843     cbp_a = (h->left_cbp>>4)&0x03;
844     cbp_b = (h-> top_cbp>>4)&0x03;
845
846     ctx = 0;
847     if( cbp_a > 0 ) ctx++;
848     if( cbp_b > 0 ) ctx += 2;
849     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
850         return 0;
851
852     ctx = 4;
853     if( cbp_a == 2 ) ctx++;
854     if( cbp_b == 2 ) ctx += 2;
855     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
856 }
857
858 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
859     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
860         return 0;   /* 8x8 */
861     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
862         return 1;   /* 8x4 */
863     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
864         return 2;   /* 4x8 */
865     return 3;       /* 4x4 */
866 }
867 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
868     int type;
869     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
870         return 0;   /* B_Direct_8x8 */
871     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
872         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
873     type = 3;
874     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
875         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
876             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
877         type += 4;
878     }
879     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
880     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
881     return type;
882 }
883
884 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
885     int refa = h->ref_cache[list][scan8[n] - 1];
886     int refb = h->ref_cache[list][scan8[n] - 8];
887     int ref  = 0;
888     int ctx  = 0;
889
890     if( h->slice_type_nos == FF_B_TYPE) {
891         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
892             ctx++;
893         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
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
912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
913     int mvd;
914
915     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
916 //    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
917         *mvda= 0;
918         return 0;
919     }
920
921     mvd= 1;
922     ctxbase+= 3;
923     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
924         if( mvd < 4 )
925             ctxbase++;
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-- ) {
940             mvd += get_cabac_bypass( &h->cabac )<<k;
941         }
942         *mvda=mvd < 70 ? mvd : 70;
943     }else
944         *mvda=mvd;
945     return get_cabac_bypass_sign( &h->cabac, -mvd );
946 }
947
948 #define DECODE_CABAC_MB_MVD( h,  list,  n )\
949 {\
950     int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
951                 h->mvd_cache[list][scan8[n] - 8][0];\
952     int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
953                 h->mvd_cache[list][scan8[n] - 8][1];\
954 \
955     mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
956     my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
957 }
958
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
986 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
987     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
988     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
989     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
990     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
991 };
992
993 static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
994     static const int significant_coeff_flag_offset[2][6] = {
995       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
996       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
997     };
998     static const int last_coeff_flag_offset[2][6] = {
999       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1000       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1001     };
1002     static const int coeff_abs_level_m1_offset[6] = {
1003         227+0, 227+10, 227+20, 227+30, 227+39, 426
1004     };
1005     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1006       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1007         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1008         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1009        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1010       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1011         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1012         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1013         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1014     };
1015     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1016      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1017      * map node ctx => cabac ctx for level=1 */
1018     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1019     /* map node ctx => cabac ctx for level>1 */
1020     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1021     static const uint8_t coeff_abs_level_transition[2][8] = {
1022     /* update node ctx after decoding a level=1 */
1023         { 1, 2, 3, 3, 4, 5, 6, 7 },
1024     /* update node ctx after decoding a level>1 */
1025         { 4, 4, 4, 4, 5, 6, 7, 7 }
1026     };
1027
1028     int index[64];
1029
1030     int av_unused last;
1031     int coeff_count = 0;
1032     int node_ctx = 0;
1033
1034     uint8_t *significant_coeff_ctx_base;
1035     uint8_t *last_coeff_ctx_base;
1036     uint8_t *abs_level_m1_ctx_base;
1037
1038 #if !ARCH_X86
1039 #define CABAC_ON_STACK
1040 #endif
1041 #ifdef CABAC_ON_STACK
1042 #define CC &cc
1043     CABACContext cc;
1044     cc.range     = h->cabac.range;
1045     cc.low       = h->cabac.low;
1046     cc.bytestream= h->cabac.bytestream;
1047 #else
1048 #define CC &h->cabac
1049 #endif
1050
1051
1052     /* cat: 0-> DC 16x16  n = 0
1053      *      1-> AC 16x16  n = luma4x4idx
1054      *      2-> Luma4x4   n = luma4x4idx
1055      *      3-> DC Chroma n = iCbCr
1056      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1057      *      5-> Luma8x8   n = 4 * luma8x8idx
1058      */
1059
1060     /* read coded block flag */
1061     if( is_dc || cat != 5 ) {
1062         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1063             if( !is_dc )
1064                 h->non_zero_count_cache[scan8[n]] = 0;
1065
1066 #ifdef CABAC_ON_STACK
1067             h->cabac.range     = cc.range     ;
1068             h->cabac.low       = cc.low       ;
1069             h->cabac.bytestream= cc.bytestream;
1070 #endif
1071             return;
1072         }
1073     }
1074
1075     significant_coeff_ctx_base = h->cabac_state
1076         + significant_coeff_flag_offset[MB_FIELD][cat];
1077     last_coeff_ctx_base = h->cabac_state
1078         + last_coeff_flag_offset[MB_FIELD][cat];
1079     abs_level_m1_ctx_base = h->cabac_state
1080         + coeff_abs_level_m1_offset[cat];
1081
1082     if( !is_dc && cat == 5 ) {
1083 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1084         for(last= 0; last < coefs; last++) { \
1085             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1086             if( get_cabac( CC, sig_ctx )) { \
1087                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1088                 index[coeff_count++] = last; \
1089                 if( get_cabac( CC, last_ctx ) ) { \
1090                     last= max_coeff; \
1091                     break; \
1092                 } \
1093             } \
1094         }\
1095         if( last == max_coeff -1 ) {\
1096             index[coeff_count++] = last;\
1097         }
1098         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1099 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1100         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1101     } else {
1102         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1103 #else
1104         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1105     } else {
1106         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1107 #endif
1108     }
1109     assert(coeff_count > 0);
1110
1111     if( is_dc ) {
1112         if( cat == 0 )
1113             h->cbp_table[h->mb_xy] |= 0x100;
1114         else
1115             h->cbp_table[h->mb_xy] |= 0x40 << n;
1116     } else {
1117         if( cat == 5 )
1118             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1119         else {
1120             assert( cat == 1 || cat == 2 || cat == 4 );
1121             h->non_zero_count_cache[scan8[n]] = coeff_count;
1122         }
1123     }
1124
1125     do {
1126         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1127
1128         int j= scantable[index[--coeff_count]];
1129
1130         if( get_cabac( CC, ctx ) == 0 ) {
1131             node_ctx = coeff_abs_level_transition[0][node_ctx];
1132             if( is_dc ) {
1133                 block[j] = get_cabac_bypass_sign( CC, -1);
1134             }else{
1135                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1136             }
1137         } else {
1138             int coeff_abs = 2;
1139             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1140             node_ctx = coeff_abs_level_transition[1][node_ctx];
1141
1142             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1143                 coeff_abs++;
1144             }
1145
1146             if( coeff_abs >= 15 ) {
1147                 int j = 0;
1148                 while( get_cabac_bypass( CC ) ) {
1149                     j++;
1150                 }
1151
1152                 coeff_abs=1;
1153                 while( j-- ) {
1154                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
1155                 }
1156                 coeff_abs+= 14;
1157             }
1158
1159             if( is_dc ) {
1160                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1161             }else{
1162                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1163             }
1164         }
1165     } while( coeff_count );
1166 #ifdef CABAC_ON_STACK
1167             h->cabac.range     = cc.range     ;
1168             h->cabac.low       = cc.low       ;
1169             h->cabac.bytestream= cc.bytestream;
1170 #endif
1171
1172 }
1173
1174 #if !CONFIG_SMALL
1175 static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1176     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1177 }
1178
1179 static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1180     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1181 }
1182 #endif
1183
1184 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1185 #if CONFIG_SMALL
1186     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1187 #else
1188     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1189     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1190 #endif
1191 }
1192
1193 /**
1194  * decodes a macroblock
1195  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1196  */
1197 int ff_h264_decode_mb_cabac(H264Context *h) {
1198     MpegEncContext * const s = &h->s;
1199     int mb_xy;
1200     int mb_type, partition_count, cbp = 0;
1201     int dct8x8_allowed= h->pps.transform_8x8_mode;
1202
1203     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1204
1205     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1206     if( h->slice_type_nos != FF_I_TYPE ) {
1207         int skip;
1208         /* a skipped mb needs the aff flag from the following mb */
1209         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1210             skip = h->next_mb_skipped;
1211         else
1212             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1213         /* read skip flags */
1214         if( skip ) {
1215             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1216                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1217                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1218                 if(!h->next_mb_skipped)
1219                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1220             }
1221
1222             decode_mb_skip(h);
1223
1224             h->cbp_table[mb_xy] = 0;
1225             h->chroma_pred_mode_table[mb_xy] = 0;
1226             h->last_qscale_diff = 0;
1227
1228             return 0;
1229
1230         }
1231     }
1232     if(FRAME_MBAFF){
1233         if( (s->mb_y&1) == 0 )
1234             h->mb_mbaff =
1235             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1236     }
1237
1238     h->prev_mb_skipped = 0;
1239
1240     fill_decode_neighbors(h, -(MB_FIELD));
1241
1242     if( h->slice_type_nos == FF_B_TYPE ) {
1243         int ctx = 0;
1244         assert(h->slice_type_nos == FF_B_TYPE);
1245
1246         if( !IS_DIRECT( h->left_type[0]-1 ) )
1247             ctx++;
1248         if( !IS_DIRECT( h->top_type-1 ) )
1249             ctx++;
1250
1251         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1252             mb_type= 0; /* B_Direct_16x16 */
1253         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1254             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1255         }else{
1256             int bits;
1257             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1258             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1259             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1260             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1261             if( bits < 8 ){
1262                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1263             }else if( bits == 13 ){
1264                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1265                 goto decode_intra_mb;
1266             }else if( bits == 14 ){
1267                 mb_type= 11; /* B_L1_L0_8x16 */
1268             }else if( bits == 15 ){
1269                 mb_type= 22; /* B_8x8 */
1270             }else{
1271                 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1272                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1273             }
1274         }
1275             partition_count= b_mb_type_info[mb_type].partition_count;
1276             mb_type=         b_mb_type_info[mb_type].type;
1277     } else if( h->slice_type_nos == FF_P_TYPE ) {
1278         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1279             /* P-type */
1280             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1281                 /* P_L0_D16x16, P_8x8 */
1282                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1283             } else {
1284                 /* P_L0_D8x16, P_L0_D16x8 */
1285                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1286             }
1287             partition_count= p_mb_type_info[mb_type].partition_count;
1288             mb_type=         p_mb_type_info[mb_type].type;
1289         } else {
1290             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1291             goto decode_intra_mb;
1292         }
1293     } else {
1294         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1295         if(h->slice_type == FF_SI_TYPE && mb_type)
1296             mb_type--;
1297         assert(h->slice_type_nos == FF_I_TYPE);
1298 decode_intra_mb:
1299         partition_count = 0;
1300         cbp= i_mb_type_info[mb_type].cbp;
1301         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1302         mb_type= i_mb_type_info[mb_type].type;
1303     }
1304     if(MB_FIELD)
1305         mb_type |= MB_TYPE_INTERLACED;
1306
1307     h->slice_table[ mb_xy ]= h->slice_num;
1308
1309     if(IS_INTRA_PCM(mb_type)) {
1310         const uint8_t *ptr;
1311
1312         // We assume these blocks are very rare so we do not optimize it.
1313         // FIXME The two following lines get the bitstream position in the cabac
1314         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1315         ptr= h->cabac.bytestream;
1316         if(h->cabac.low&0x1) ptr--;
1317         if(CABAC_BITS==16){
1318             if(h->cabac.low&0x1FF) ptr--;
1319         }
1320
1321         // The pixels are stored in the same order as levels in h->mb array.
1322         memcpy(h->mb, ptr, 256); ptr+=256;
1323         if(CHROMA){
1324             memcpy(h->mb+128, ptr, 128); ptr+=128;
1325         }
1326
1327         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1328
1329         // All blocks are present
1330         h->cbp_table[mb_xy] = 0x1ef;
1331         h->chroma_pred_mode_table[mb_xy] = 0;
1332         // In deblocking, the quantizer is 0
1333         s->current_picture.qscale_table[mb_xy]= 0;
1334         // All coeffs are present
1335         memset(h->non_zero_count[mb_xy], 16, 32);
1336         s->current_picture.mb_type[mb_xy]= mb_type;
1337         h->last_qscale_diff = 0;
1338         return 0;
1339     }
1340
1341     if(MB_MBAFF){
1342         h->ref_count[0] <<= 1;
1343         h->ref_count[1] <<= 1;
1344     }
1345
1346     fill_decode_caches(h, mb_type);
1347
1348     if( IS_INTRA( mb_type ) ) {
1349         int i, pred_mode;
1350         if( IS_INTRA4x4( mb_type ) ) {
1351             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1352                 mb_type |= MB_TYPE_8x8DCT;
1353                 for( i = 0; i < 16; i+=4 ) {
1354                     int pred = pred_intra_mode( h, i );
1355                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1356                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1357                 }
1358             } else {
1359                 for( i = 0; i < 16; i++ ) {
1360                     int pred = pred_intra_mode( h, i );
1361                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1362
1363                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1364                 }
1365             }
1366             ff_h264_write_back_intra_pred_mode(h);
1367             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1368         } else {
1369             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1370             if( h->intra16x16_pred_mode < 0 ) return -1;
1371         }
1372         if(CHROMA){
1373             h->chroma_pred_mode_table[mb_xy] =
1374             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1375
1376             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1377             if( pred_mode < 0 ) return -1;
1378             h->chroma_pred_mode= pred_mode;
1379         }
1380     } else if( partition_count == 4 ) {
1381         int i, j, sub_partition_count[4], list, ref[2][4];
1382
1383         if( h->slice_type_nos == FF_B_TYPE ) {
1384             for( i = 0; i < 4; i++ ) {
1385                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1386                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1387                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1388             }
1389             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1390                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1391                 ff_h264_pred_direct_motion(h, &mb_type);
1392                 h->ref_cache[0][scan8[4]] =
1393                 h->ref_cache[1][scan8[4]] =
1394                 h->ref_cache[0][scan8[12]] =
1395                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1396                     for( i = 0; i < 4; i++ )
1397                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1398             }
1399         } else {
1400             for( i = 0; i < 4; i++ ) {
1401                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1402                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1403                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1404             }
1405         }
1406
1407         for( list = 0; list < h->list_count; list++ ) {
1408                 for( i = 0; i < 4; i++ ) {
1409                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1410                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1411                         if( h->ref_count[list] > 1 ){
1412                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1413                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1414                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1415                                 return -1;
1416                             }
1417                         }else
1418                             ref[list][i] = 0;
1419                     } else {
1420                         ref[list][i] = -1;
1421                     }
1422                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1423                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1424                 }
1425         }
1426
1427         if(dct8x8_allowed)
1428             dct8x8_allowed = get_dct8x8_allowed(h);
1429
1430         for(list=0; list<h->list_count; list++){
1431             for(i=0; i<4; i++){
1432                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1433                 if(IS_DIRECT(h->sub_mb_type[i])){
1434                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1435                     continue;
1436                 }
1437
1438                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1439                     const int sub_mb_type= h->sub_mb_type[i];
1440                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1441                     for(j=0; j<sub_partition_count[i]; j++){
1442                         int mpx, mpy;
1443                         int mx, my;
1444                         const int index= 4*i + block_width*j;
1445                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1446                         uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1447                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1448                         DECODE_CABAC_MB_MVD( h, list, index)
1449                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1450
1451                         if(IS_SUB_8X8(sub_mb_type)){
1452                             mv_cache[ 1 ][0]=
1453                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1454                             mv_cache[ 1 ][1]=
1455                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1456
1457                             mvd_cache[ 1 ][0]=
1458                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1459                             mvd_cache[ 1 ][1]=
1460                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1461                         }else if(IS_SUB_8X4(sub_mb_type)){
1462                             mv_cache[ 1 ][0]= mx;
1463                             mv_cache[ 1 ][1]= my;
1464
1465                             mvd_cache[ 1 ][0]=  mpx;
1466                             mvd_cache[ 1 ][1]= mpy;
1467                         }else if(IS_SUB_4X8(sub_mb_type)){
1468                             mv_cache[ 8 ][0]= mx;
1469                             mv_cache[ 8 ][1]= my;
1470
1471                             mvd_cache[ 8 ][0]= mpx;
1472                             mvd_cache[ 8 ][1]= mpy;
1473                         }
1474                         mv_cache[ 0 ][0]= mx;
1475                         mv_cache[ 0 ][1]= my;
1476
1477                         mvd_cache[ 0 ][0]= mpx;
1478                         mvd_cache[ 0 ][1]= mpy;
1479                     }
1480                 }else{
1481                     fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1482                     fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1483                 }
1484             }
1485         }
1486     } else if( IS_DIRECT(mb_type) ) {
1487         ff_h264_pred_direct_motion(h, &mb_type);
1488         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1489         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1490         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1491     } else {
1492         int list, i;
1493         if(IS_16X16(mb_type)){
1494             for(list=0; list<h->list_count; list++){
1495                 if(IS_DIR(mb_type, 0, list)){
1496                     int ref;
1497                     if(h->ref_count[list] > 1){
1498                         ref= decode_cabac_mb_ref(h, list, 0);
1499                         if(ref >= (unsigned)h->ref_count[list]){
1500                             av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1501                             return -1;
1502                         }
1503                     }else
1504                         ref=0;
1505                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1506                 }else
1507                     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
1508             }
1509             for(list=0; list<h->list_count; list++){
1510                 if(IS_DIR(mb_type, 0, list)){
1511                     int mx,my,mpx,mpy;
1512                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1513                     DECODE_CABAC_MB_MVD( h, list, 0)
1514                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1515
1516                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1517                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1518                 }else
1519                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1520             }
1521         }
1522         else if(IS_16X8(mb_type)){
1523             for(list=0; list<h->list_count; list++){
1524                     for(i=0; i<2; i++){
1525                         if(IS_DIR(mb_type, i, list)){
1526                             int ref;
1527                             if(h->ref_count[list] > 1){
1528                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1529                                 if(ref >= (unsigned)h->ref_count[list]){
1530                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1531                                     return -1;
1532                                 }
1533                             }else
1534                                 ref=0;
1535                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1536                         }else
1537                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1538                     }
1539             }
1540             for(list=0; list<h->list_count; list++){
1541                 for(i=0; i<2; i++){
1542                     if(IS_DIR(mb_type, i, list)){
1543                         int mx,my,mpx,mpy;
1544                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1545                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1546                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1547
1548                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1549                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1550                     }else{
1551                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1552                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1553                     }
1554                 }
1555             }
1556         }else{
1557             assert(IS_8X16(mb_type));
1558             for(list=0; list<h->list_count; list++){
1559                     for(i=0; i<2; i++){
1560                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1561                             int ref;
1562                             if(h->ref_count[list] > 1){
1563                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1564                                 if(ref >= (unsigned)h->ref_count[list]){
1565                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1566                                     return -1;
1567                                 }
1568                             }else
1569                                 ref=0;
1570                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1571                         }else
1572                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1573                     }
1574             }
1575             for(list=0; list<h->list_count; list++){
1576                 for(i=0; i<2; i++){
1577                     if(IS_DIR(mb_type, i, list)){
1578                         int mx,my,mpx,mpy;
1579                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1580                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1581
1582                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1583                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1584                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1585                     }else{
1586                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1587                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1588                     }
1589                 }
1590             }
1591         }
1592     }
1593
1594    if( IS_INTER( mb_type ) ) {
1595         h->chroma_pred_mode_table[mb_xy] = 0;
1596         write_back_motion( h, mb_type );
1597    }
1598
1599     if( !IS_INTRA16x16( mb_type ) ) {
1600         cbp  = decode_cabac_mb_cbp_luma( h );
1601         if(CHROMA)
1602             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1603     }
1604
1605     h->cbp_table[mb_xy] = h->cbp = cbp;
1606
1607     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1608         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1609     }
1610     s->current_picture.mb_type[mb_xy]= mb_type;
1611
1612     if( cbp || IS_INTRA16x16( mb_type ) ) {
1613         const uint8_t *scan, *scan8x8, *dc_scan;
1614         const uint32_t *qmul;
1615
1616         if(IS_INTERLACED(mb_type)){
1617             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1618             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1619             dc_scan= luma_dc_field_scan;
1620         }else{
1621             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1622             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1623             dc_scan= luma_dc_zigzag_scan;
1624         }
1625
1626         // decode_cabac_mb_dqp
1627         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1628             int val = 1;
1629             int ctx= 2;
1630
1631             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1632                 ctx= 3;
1633                 val++;
1634                 if(val > 102){ //prevent infinite loop
1635                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1636                     return -1;
1637                 }
1638             }
1639
1640             if( val&0x01 )
1641                 val=   (val + 1)>>1 ;
1642             else
1643                 val= -((val + 1)>>1);
1644             h->last_qscale_diff = val;
1645             s->qscale += val;
1646             if(((unsigned)s->qscale) > 51){
1647                 if(s->qscale<0) s->qscale+= 52;
1648                 else            s->qscale-= 52;
1649             }
1650             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1651             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1652         }else
1653             h->last_qscale_diff=0;
1654
1655         if( IS_INTRA16x16( mb_type ) ) {
1656             int i;
1657             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1658             decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1659
1660             if( cbp&15 ) {
1661                 qmul = h->dequant4_coeff[0][s->qscale];
1662                 for( i = 0; i < 16; i++ ) {
1663                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1664                     decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1665                 }
1666             } else {
1667                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1668             }
1669         } else {
1670             int i8x8, i4x4;
1671             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1672                 if( cbp & (1<<i8x8) ) {
1673                     if( IS_8x8DCT(mb_type) ) {
1674                         decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1675                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1676                     } else {
1677                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1678                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1679                             const int index = 4*i8x8 + i4x4;
1680                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1681 //START_TIMER
1682                             decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1683 //STOP_TIMER("decode_residual")
1684                         }
1685                     }
1686                 } else {
1687                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1688                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1689                 }
1690             }
1691         }
1692
1693         if( cbp&0x30 ){
1694             int c;
1695             for( c = 0; c < 2; c++ ) {
1696                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1697                 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1698             }
1699         }
1700
1701         if( cbp&0x20 ) {
1702             int c, i;
1703             for( c = 0; c < 2; c++ ) {
1704                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1705                 for( i = 0; i < 4; i++ ) {
1706                     const int index = 16 + 4 * c + i;
1707                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1708                     decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1709                 }
1710             }
1711         } else {
1712             uint8_t * const nnz= &h->non_zero_count_cache[0];
1713             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1714             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1715         }
1716     } else {
1717         uint8_t * const nnz= &h->non_zero_count_cache[0];
1718         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1719         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1720         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1721         h->last_qscale_diff = 0;
1722     }
1723
1724     s->current_picture.qscale_table[mb_xy]= s->qscale;
1725     write_back_non_zero_count(h);
1726
1727     if(MB_MBAFF){
1728         h->ref_count[0] >>= 1;
1729         h->ref_count[1] >>= 1;
1730     }
1731
1732     return 0;
1733 }