Replace deprecated FF_*_TYPE symbols with AV_PICTURE_TYPE_*.
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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
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 == AV_PICTURE_TYPE_I ) 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 == AV_PICTURE_TYPE_B )
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 == AV_PICTURE_TYPE_B) {
891         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
892             ctx++;
893         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
894             ctx += 2;
895     } else {
896         if( refa > 0 )
897             ctx++;
898         if( refb > 0 )
899             ctx += 2;
900     }
901
902     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
903         ref++;
904         ctx = (ctx>>2)+4;
905         if(ref >= 32 /*h->ref_list[list]*/){
906             return -1;
907         }
908     }
909     return ref;
910 }
911
912 static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
913     int mvd;
914
915     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
916 //    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
917         *mvda= 0;
918         return 0;
919     }
920
921     mvd= 1;
922     ctxbase+= 3;
923     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
924         if( mvd < 4 )
925             ctxbase++;
926         mvd++;
927     }
928
929     if( mvd >= 9 ) {
930         int k = 3;
931         while( get_cabac_bypass( &h->cabac ) ) {
932             mvd += 1 << k;
933             k++;
934             if(k>24){
935                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
936                 return INT_MIN;
937             }
938         }
939         while( k-- ) {
940             mvd += get_cabac_bypass( &h->cabac )<<k;
941         }
942         *mvda=mvd < 70 ? mvd : 70;
943     }else
944         *mvda=mvd;
945     return get_cabac_bypass_sign( &h->cabac, -mvd );
946 }
947
948 #define DECODE_CABAC_MB_MVD( h,  list,  n )\
949 {\
950     int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
951                 h->mvd_cache[list][scan8[n] - 8][0];\
952     int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
953                 h->mvd_cache[list][scan8[n] - 8][1];\
954 \
955     mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
956     my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
957 }
958
959 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
960     int nza, nzb;
961     int ctx = 0;
962
963     if( is_dc ) {
964         if( cat == 0 ) {
965             nza = h->left_cbp&0x100;
966             nzb = h-> top_cbp&0x100;
967         } else {
968             idx -= CHROMA_DC_BLOCK_INDEX;
969             nza = (h->left_cbp>>(6+idx))&0x01;
970             nzb = (h-> top_cbp>>(6+idx))&0x01;
971         }
972     } else {
973         assert(cat == 1 || cat == 2 || cat == 4);
974         nza = h->non_zero_count_cache[scan8[idx] - 1];
975         nzb = h->non_zero_count_cache[scan8[idx] - 8];
976     }
977
978     if( nza > 0 )
979         ctx++;
980
981     if( nzb > 0 )
982         ctx += 2;
983
984     return ctx + 4 * cat;
985 }
986
987 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
988     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
989     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
990     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
991     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
992 };
993
994 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 ) {
995     static const int significant_coeff_flag_offset[2][6] = {
996       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
997       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
998     };
999     static const int last_coeff_flag_offset[2][6] = {
1000       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1001       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1002     };
1003     static const int coeff_abs_level_m1_offset[6] = {
1004         227+0, 227+10, 227+20, 227+30, 227+39, 426
1005     };
1006     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1007       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1008         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1009         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1010        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1011       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1012         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1013         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1014         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1015     };
1016     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1017      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1018      * map node ctx => cabac ctx for level=1 */
1019     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1020     /* map node ctx => cabac ctx for level>1 */
1021     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1022     static const uint8_t coeff_abs_level_transition[2][8] = {
1023     /* update node ctx after decoding a level=1 */
1024         { 1, 2, 3, 3, 4, 5, 6, 7 },
1025     /* update node ctx after decoding a level>1 */
1026         { 4, 4, 4, 4, 5, 6, 7, 7 }
1027     };
1028
1029     int index[64];
1030
1031     int av_unused last;
1032     int coeff_count = 0;
1033     int node_ctx = 0;
1034
1035     uint8_t *significant_coeff_ctx_base;
1036     uint8_t *last_coeff_ctx_base;
1037     uint8_t *abs_level_m1_ctx_base;
1038
1039 #if !ARCH_X86
1040 #define CABAC_ON_STACK
1041 #endif
1042 #ifdef CABAC_ON_STACK
1043 #define CC &cc
1044     CABACContext cc;
1045     cc.range     = h->cabac.range;
1046     cc.low       = h->cabac.low;
1047     cc.bytestream= h->cabac.bytestream;
1048 #else
1049 #define CC &h->cabac
1050 #endif
1051
1052     significant_coeff_ctx_base = h->cabac_state
1053         + significant_coeff_flag_offset[MB_FIELD][cat];
1054     last_coeff_ctx_base = h->cabac_state
1055         + last_coeff_flag_offset[MB_FIELD][cat];
1056     abs_level_m1_ctx_base = h->cabac_state
1057         + coeff_abs_level_m1_offset[cat];
1058
1059     if( !is_dc && cat == 5 ) {
1060 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1061         for(last= 0; last < coefs; last++) { \
1062             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1063             if( get_cabac( CC, sig_ctx )) { \
1064                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1065                 index[coeff_count++] = last; \
1066                 if( get_cabac( CC, last_ctx ) ) { \
1067                     last= max_coeff; \
1068                     break; \
1069                 } \
1070             } \
1071         }\
1072         if( last == max_coeff -1 ) {\
1073             index[coeff_count++] = last;\
1074         }
1075         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1076 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1077         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1078     } else {
1079         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1080 #else
1081         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1082     } else {
1083         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1084 #endif
1085     }
1086     assert(coeff_count > 0);
1087
1088     if( is_dc ) {
1089         if( cat == 0 )
1090             h->cbp_table[h->mb_xy] |= 0x100;
1091         else
1092             h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
1093         h->non_zero_count_cache[scan8[n]] = coeff_count;
1094     } else {
1095         if( cat == 5 )
1096             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1097         else {
1098             assert( cat == 1 || cat == 2 || cat == 4 );
1099             h->non_zero_count_cache[scan8[n]] = coeff_count;
1100         }
1101     }
1102
1103     do {
1104         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1105
1106         int j= scantable[index[--coeff_count]];
1107
1108         if( get_cabac( CC, ctx ) == 0 ) {
1109             node_ctx = coeff_abs_level_transition[0][node_ctx];
1110             if( is_dc ) {
1111                 block[j] = get_cabac_bypass_sign( CC, -1);
1112             }else{
1113                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1114             }
1115         } else {
1116             int coeff_abs = 2;
1117             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1118             node_ctx = coeff_abs_level_transition[1][node_ctx];
1119
1120             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1121                 coeff_abs++;
1122             }
1123
1124             if( coeff_abs >= 15 ) {
1125                 int j = 0;
1126                 while( get_cabac_bypass( CC ) ) {
1127                     j++;
1128                 }
1129
1130                 coeff_abs=1;
1131                 while( j-- ) {
1132                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
1133                 }
1134                 coeff_abs+= 14;
1135             }
1136
1137             if( is_dc ) {
1138                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1139             }else{
1140                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1141             }
1142         }
1143     } while( coeff_count );
1144 #ifdef CABAC_ON_STACK
1145             h->cabac.range     = cc.range     ;
1146             h->cabac.low       = cc.low       ;
1147             h->cabac.bytestream= cc.bytestream;
1148 #endif
1149
1150 }
1151
1152 static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1153     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1154 }
1155
1156 static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1157     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1158 }
1159
1160 /* cat: 0-> DC 16x16  n = 0
1161  *      1-> AC 16x16  n = luma4x4idx
1162  *      2-> Luma4x4   n = luma4x4idx
1163  *      3-> DC Chroma n = iCbCr
1164  *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1165  *      5-> Luma8x8   n = 4 * luma8x8idx */
1166
1167 /* Partially inline the CABAC residual decode: inline the coded block flag.
1168  * This has very little impact on binary size and improves performance
1169  * because it allows improved constant propagation into get_cabac_cbf_ctx,
1170  * as well as because most blocks have zero CBFs. */
1171
1172 static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1173     /* read coded block flag */
1174     if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1175         h->non_zero_count_cache[scan8[n]] = 0;
1176         return;
1177     }
1178     decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1179 }
1180
1181 static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1182     /* read coded block flag */
1183     if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1184         h->non_zero_count_cache[scan8[n]] = 0;
1185         return;
1186     }
1187     decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1188 }
1189
1190 /**
1191  * decodes a macroblock
1192  * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1193  */
1194 int ff_h264_decode_mb_cabac(H264Context *h) {
1195     MpegEncContext * const s = &h->s;
1196     int mb_xy;
1197     int mb_type, partition_count, cbp = 0;
1198     int dct8x8_allowed= h->pps.transform_8x8_mode;
1199
1200     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1201
1202     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1203     if( h->slice_type_nos != AV_PICTURE_TYPE_I ) {
1204         int skip;
1205         /* a skipped mb needs the aff flag from the following mb */
1206         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1207             skip = h->next_mb_skipped;
1208         else
1209             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1210         /* read skip flags */
1211         if( skip ) {
1212             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1213                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1214                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1215                 if(!h->next_mb_skipped)
1216                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1217             }
1218
1219             decode_mb_skip(h);
1220
1221             h->cbp_table[mb_xy] = 0;
1222             h->chroma_pred_mode_table[mb_xy] = 0;
1223             h->last_qscale_diff = 0;
1224
1225             return 0;
1226
1227         }
1228     }
1229     if(FRAME_MBAFF){
1230         if( (s->mb_y&1) == 0 )
1231             h->mb_mbaff =
1232             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1233     }
1234
1235     h->prev_mb_skipped = 0;
1236
1237     fill_decode_neighbors(h, -(MB_FIELD));
1238
1239     if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
1240         int ctx = 0;
1241         assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
1242
1243         if( !IS_DIRECT( h->left_type[0]-1 ) )
1244             ctx++;
1245         if( !IS_DIRECT( h->top_type-1 ) )
1246             ctx++;
1247
1248         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1249             mb_type= 0; /* B_Direct_16x16 */
1250         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1251             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1252         }else{
1253             int bits;
1254             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1255             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1256             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1257             bits+= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1258             if( bits < 8 ){
1259                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1260             }else if( bits == 13 ){
1261                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1262                 goto decode_intra_mb;
1263             }else if( bits == 14 ){
1264                 mb_type= 11; /* B_L1_L0_8x16 */
1265             }else if( bits == 15 ){
1266                 mb_type= 22; /* B_8x8 */
1267             }else{
1268                 bits= ( bits<<1 ) + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1269                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1270             }
1271         }
1272             partition_count= b_mb_type_info[mb_type].partition_count;
1273             mb_type=         b_mb_type_info[mb_type].type;
1274     } else if( h->slice_type_nos == AV_PICTURE_TYPE_P ) {
1275         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1276             /* P-type */
1277             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1278                 /* P_L0_D16x16, P_8x8 */
1279                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1280             } else {
1281                 /* P_L0_D8x16, P_L0_D16x8 */
1282                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1283             }
1284             partition_count= p_mb_type_info[mb_type].partition_count;
1285             mb_type=         p_mb_type_info[mb_type].type;
1286         } else {
1287             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1288             goto decode_intra_mb;
1289         }
1290     } else {
1291         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1292         if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
1293             mb_type--;
1294         assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
1295 decode_intra_mb:
1296         partition_count = 0;
1297         cbp= i_mb_type_info[mb_type].cbp;
1298         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1299         mb_type= i_mb_type_info[mb_type].type;
1300     }
1301     if(MB_FIELD)
1302         mb_type |= MB_TYPE_INTERLACED;
1303
1304     h->slice_table[ mb_xy ]= h->slice_num;
1305
1306     if(IS_INTRA_PCM(mb_type)) {
1307         const uint8_t *ptr;
1308
1309         // We assume these blocks are very rare so we do not optimize it.
1310         // FIXME The two following lines get the bitstream position in the cabac
1311         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1312         ptr= h->cabac.bytestream;
1313         if(h->cabac.low&0x1) ptr--;
1314         if(CABAC_BITS==16){
1315             if(h->cabac.low&0x1FF) ptr--;
1316         }
1317
1318         // The pixels are stored in the same order as levels in h->mb array.
1319         memcpy(h->mb, ptr, 256); ptr+=256;
1320         if(CHROMA){
1321             memcpy(h->mb+128, ptr, 128); ptr+=128;
1322         }
1323
1324         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1325
1326         // All blocks are present
1327         h->cbp_table[mb_xy] = 0x1ef;
1328         h->chroma_pred_mode_table[mb_xy] = 0;
1329         // In deblocking, the quantizer is 0
1330         s->current_picture.qscale_table[mb_xy]= 0;
1331         // All coeffs are present
1332         memset(h->non_zero_count[mb_xy], 16, 32);
1333         s->current_picture.mb_type[mb_xy]= mb_type;
1334         h->last_qscale_diff = 0;
1335         return 0;
1336     }
1337
1338     if(MB_MBAFF){
1339         h->ref_count[0] <<= 1;
1340         h->ref_count[1] <<= 1;
1341     }
1342
1343     fill_decode_caches(h, mb_type);
1344
1345     if( IS_INTRA( mb_type ) ) {
1346         int i, pred_mode;
1347         if( IS_INTRA4x4( mb_type ) ) {
1348             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1349                 mb_type |= MB_TYPE_8x8DCT;
1350                 for( i = 0; i < 16; i+=4 ) {
1351                     int pred = pred_intra_mode( h, i );
1352                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1353                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1354                 }
1355             } else {
1356                 for( i = 0; i < 16; i++ ) {
1357                     int pred = pred_intra_mode( h, i );
1358                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1359
1360                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1361                 }
1362             }
1363             ff_h264_write_back_intra_pred_mode(h);
1364             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1365         } else {
1366             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1367             if( h->intra16x16_pred_mode < 0 ) return -1;
1368         }
1369         if(CHROMA){
1370             h->chroma_pred_mode_table[mb_xy] =
1371             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1372
1373             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1374             if( pred_mode < 0 ) return -1;
1375             h->chroma_pred_mode= pred_mode;
1376         } else {
1377             h->chroma_pred_mode= DC_128_PRED8x8;
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 == AV_PICTURE_TYPE_B ) {
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                 }
1506             }
1507             for(list=0; list<h->list_count; list++){
1508                 if(IS_DIR(mb_type, 0, list)){
1509                     int mx,my,mpx,mpy;
1510                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1511                     DECODE_CABAC_MB_MVD( h, list, 0)
1512                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1513
1514                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack8to16(mpx,mpy), 2);
1515                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1516                 }
1517             }
1518         }
1519         else if(IS_16X8(mb_type)){
1520             for(list=0; list<h->list_count; list++){
1521                     for(i=0; i<2; i++){
1522                         if(IS_DIR(mb_type, i, list)){
1523                             int ref;
1524                             if(h->ref_count[list] > 1){
1525                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1526                                 if(ref >= (unsigned)h->ref_count[list]){
1527                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1528                                     return -1;
1529                                 }
1530                             }else
1531                                 ref=0;
1532                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1533                         }else
1534                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1535                     }
1536             }
1537             for(list=0; list<h->list_count; list++){
1538                 for(i=0; i<2; i++){
1539                     if(IS_DIR(mb_type, i, list)){
1540                         int mx,my,mpx,mpy;
1541                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1542                         DECODE_CABAC_MB_MVD( h, list, 8*i)
1543                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1544
1545                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack8to16(mpx,mpy), 2);
1546                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1547                     }else{
1548                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 2);
1549                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1550                     }
1551                 }
1552             }
1553         }else{
1554             assert(IS_8X16(mb_type));
1555             for(list=0; list<h->list_count; list++){
1556                     for(i=0; i<2; i++){
1557                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1558                             int ref;
1559                             if(h->ref_count[list] > 1){
1560                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1561                                 if(ref >= (unsigned)h->ref_count[list]){
1562                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1563                                     return -1;
1564                                 }
1565                             }else
1566                                 ref=0;
1567                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1568                         }else
1569                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1570                     }
1571             }
1572             for(list=0; list<h->list_count; list++){
1573                 for(i=0; i<2; i++){
1574                     if(IS_DIR(mb_type, i, list)){
1575                         int mx,my,mpx,mpy;
1576                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1577                         DECODE_CABAC_MB_MVD( h, list, 4*i)
1578
1579                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1580                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack8to16(mpx,mpy), 2);
1581                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1582                     }else{
1583                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 2);
1584                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1585                     }
1586                 }
1587             }
1588         }
1589     }
1590
1591    if( IS_INTER( mb_type ) ) {
1592         h->chroma_pred_mode_table[mb_xy] = 0;
1593         write_back_motion( h, mb_type );
1594    }
1595
1596     if( !IS_INTRA16x16( mb_type ) ) {
1597         cbp  = decode_cabac_mb_cbp_luma( h );
1598         if(CHROMA)
1599             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1600     }
1601
1602     h->cbp_table[mb_xy] = h->cbp = cbp;
1603
1604     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1605         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1606     }
1607     s->current_picture.mb_type[mb_xy]= mb_type;
1608
1609     if( cbp || IS_INTRA16x16( mb_type ) ) {
1610         const uint8_t *scan, *scan8x8;
1611         const uint32_t *qmul;
1612
1613         if(IS_INTERLACED(mb_type)){
1614             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1615             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1616         }else{
1617             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1618             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
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             AV_ZERO128(h->mb_luma_dc+0);
1654             AV_ZERO128(h->mb_luma_dc+8);
1655             decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1656
1657             if( cbp&15 ) {
1658                 qmul = h->dequant4_coeff[0][s->qscale];
1659                 for( i = 0; i < 16; i++ ) {
1660                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1661                     decode_cabac_residual_nondc(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1662                 }
1663             } else {
1664                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1665             }
1666         } else {
1667             int i8x8, i4x4;
1668             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1669                 if( cbp & (1<<i8x8) ) {
1670                     if( IS_8x8DCT(mb_type) ) {
1671                         decode_cabac_residual_nondc(h, h->mb + 64*i8x8, 5, 4*i8x8,
1672                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1673                     } else {
1674                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1675                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1676                             const int index = 4*i8x8 + i4x4;
1677                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1678 //START_TIMER
1679                             decode_cabac_residual_nondc(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1680 //STOP_TIMER("decode_residual")
1681                         }
1682                     }
1683                 } else {
1684                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1685                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1686                 }
1687             }
1688         }
1689
1690         if( cbp&0x30 ){
1691             int c;
1692             for( c = 0; c < 2; c++ ) {
1693                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1694                 decode_cabac_residual_dc(h, h->mb + 256 + 16*4*c, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1695             }
1696         }
1697
1698         if( cbp&0x20 ) {
1699             int c, i;
1700             for( c = 0; c < 2; c++ ) {
1701                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1702                 for( i = 0; i < 4; i++ ) {
1703                     const int index = 16 + 4 * c + i;
1704                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1705                     decode_cabac_residual_nondc(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1706                 }
1707             }
1708         } else {
1709             uint8_t * const nnz= &h->non_zero_count_cache[0];
1710             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1711             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1712         }
1713     } else {
1714         uint8_t * const nnz= &h->non_zero_count_cache[0];
1715         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1716         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1717         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1718         h->last_qscale_diff = 0;
1719     }
1720
1721     s->current_picture.qscale_table[mb_xy]= s->qscale;
1722     write_back_non_zero_count(h);
1723
1724     if(MB_MBAFF){
1725         h->ref_count[0] >>= 1;
1726         h->ref_count[1] >>= 1;
1727     }
1728
1729     return 0;
1730 }