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