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