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