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