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