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