7a37df5607ab0079e5877bf3f9c554a296c56903
[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
692     /* calculate pre-state */
693     for( i= 0; i < 460; i++ ) {
694         int pre;
695         if( h->slice_type_nos == FF_I_TYPE )
696             pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
697         else
698             pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
699
700         if( pre <= 63 )
701             h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
702         else
703             h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
704     }
705 }
706
707 static int decode_cabac_field_decoding_flag(H264Context *h) {
708     MpegEncContext * const s = &h->s;
709     const long mba_xy = h->mb_xy - 1L;
710     const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
711
712     unsigned long ctx = 0;
713
714     ctx += (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         MpegEncContext * const s = &h->s;
726         const int mba_xy = h->left_mb_xy[0];
727         const int mbb_xy = h->top_mb_xy;
728         int ctx=0;
729         if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
730             ctx++;
731         if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
732             ctx++;
733         if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
734             return 0;   /* I4x4 */
735         state += 2;
736     }else{
737         if( get_cabac_noinline( &h->cabac, state ) == 0 )
738             return 0;   /* I4x4 */
739     }
740
741     if( get_cabac_terminate( &h->cabac ) )
742         return 25;  /* PCM */
743
744     mb_type = 1; /* I16x16 */
745     mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
746     if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
747         mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
748     mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
749     mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
750     return mb_type;
751 }
752
753 static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
754     MpegEncContext * const s = &h->s;
755     int mba_xy, mbb_xy;
756     int ctx = 0;
757
758     if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
759         int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
760         mba_xy = mb_xy - 1;
761         if( (mb_y&1)
762             && h->slice_table[mba_xy] == h->slice_num
763             && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
764             mba_xy += s->mb_stride;
765         if( MB_FIELD ){
766             mbb_xy = mb_xy - s->mb_stride;
767             if( !(mb_y&1)
768                 && h->slice_table[mbb_xy] == h->slice_num
769                 && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
770                 mbb_xy -= s->mb_stride;
771         }else
772             mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
773     }else{
774         int mb_xy = h->mb_xy;
775         mba_xy = mb_xy - 1;
776         mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
777     }
778
779     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
780         ctx++;
781     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
782         ctx++;
783
784     if( h->slice_type_nos == FF_B_TYPE )
785         ctx += 13;
786     return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
787 }
788
789 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
790     int mode = 0;
791
792     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
793         return pred_mode;
794
795     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
796     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
797     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
798
799     return mode + ( mode >= pred_mode );
800 }
801
802 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
803     const int mba_xy = h->left_mb_xy[0];
804     const int mbb_xy = h->top_mb_xy;
805
806     int ctx = 0;
807
808     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
809     if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
810         ctx++;
811
812     if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
813         ctx++;
814
815     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
816         return 0;
817
818     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
819         return 1;
820     if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
821         return 2;
822     else
823         return 3;
824 }
825
826 static int decode_cabac_mb_cbp_luma( H264Context *h) {
827     int cbp_b, cbp_a, ctx, cbp = 0;
828
829     cbp_a = h->left_cbp;
830     cbp_b = h->top_cbp;
831
832     ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
833     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
834     ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
835     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
836     ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
837     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
838     ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
839     cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
840     return cbp;
841 }
842 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
843     int ctx;
844     int cbp_a, cbp_b;
845
846     cbp_a = (h->left_cbp>>4)&0x03;
847     cbp_b = (h-> top_cbp>>4)&0x03;
848
849     ctx = 0;
850     if( cbp_a > 0 ) ctx++;
851     if( cbp_b > 0 ) ctx += 2;
852     if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
853         return 0;
854
855     ctx = 4;
856     if( cbp_a == 2 ) ctx++;
857     if( cbp_b == 2 ) ctx += 2;
858     return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
859 }
860
861 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
862     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
863         return 0;   /* 8x8 */
864     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
865         return 1;   /* 8x4 */
866     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
867         return 2;   /* 4x8 */
868     return 3;       /* 4x4 */
869 }
870 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
871     int type;
872     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
873         return 0;   /* B_Direct_8x8 */
874     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
875         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
876     type = 3;
877     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
878         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
879             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
880         type += 4;
881     }
882     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
883     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
884     return type;
885 }
886
887 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
888     int refa = h->ref_cache[list][scan8[n] - 1];
889     int refb = h->ref_cache[list][scan8[n] - 8];
890     int ref  = 0;
891     int ctx  = 0;
892
893     if( h->slice_type_nos == FF_B_TYPE) {
894         if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
895             ctx++;
896         if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
897             ctx += 2;
898     } else {
899         if( refa > 0 )
900             ctx++;
901         if( refb > 0 )
902             ctx += 2;
903     }
904
905     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
906         ref++;
907         ctx = (ctx>>2)+4;
908         if(ref >= 32 /*h->ref_list[list]*/){
909             return -1;
910         }
911     }
912     return ref;
913 }
914
915 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
916     int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
917                abs( h->mvd_cache[list][scan8[n] - 8][l] );
918     int ctxbase = (l == 0) ? 40 : 47;
919     int mvd;
920     int ctx = (amvd>2) + (amvd>32);
921
922     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
923         return 0;
924
925     mvd= 1;
926     ctx= 3;
927     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
928         mvd++;
929         if( ctx < 6 )
930             ctx++;
931     }
932
933     if( mvd >= 9 ) {
934         int k = 3;
935         while( get_cabac_bypass( &h->cabac ) ) {
936             mvd += 1 << k;
937             k++;
938             if(k>24){
939                 av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
940                 return INT_MIN;
941             }
942         }
943         while( k-- ) {
944             if( get_cabac_bypass( &h->cabac ) )
945                 mvd += 1 << k;
946         }
947     }
948     return get_cabac_bypass_sign( &h->cabac, -mvd );
949 }
950
951 static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
952     int nza, nzb;
953     int ctx = 0;
954
955     if( is_dc ) {
956         if( cat == 0 ) {
957             nza = h->left_cbp&0x100;
958             nzb = h-> top_cbp&0x100;
959         } else {
960             nza = (h->left_cbp>>(6+idx))&0x01;
961             nzb = (h-> top_cbp>>(6+idx))&0x01;
962         }
963     } else {
964         assert(cat == 1 || cat == 2 || cat == 4);
965         nza = h->non_zero_count_cache[scan8[idx] - 1];
966         nzb = h->non_zero_count_cache[scan8[idx] - 8];
967     }
968
969     if( nza > 0 )
970         ctx++;
971
972     if( nzb > 0 )
973         ctx += 2;
974
975     return ctx + 4 * cat;
976 }
977
978 DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
979     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
980     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
981     3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
982     5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
983 };
984
985 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 ) {
986     static const int significant_coeff_flag_offset[2][6] = {
987       { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
988       { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
989     };
990     static const int last_coeff_flag_offset[2][6] = {
991       { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
992       { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
993     };
994     static const int coeff_abs_level_m1_offset[6] = {
995         227+0, 227+10, 227+20, 227+30, 227+39, 426
996     };
997     static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
998       { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
999         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1000         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1001        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1002       { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1003         6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1004         9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1005         9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1006     };
1007     /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1008      * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1009      * map node ctx => cabac ctx for level=1 */
1010     static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1011     /* map node ctx => cabac ctx for level>1 */
1012     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1013     static const uint8_t coeff_abs_level_transition[2][8] = {
1014     /* update node ctx after decoding a level=1 */
1015         { 1, 2, 3, 3, 4, 5, 6, 7 },
1016     /* update node ctx after decoding a level>1 */
1017         { 4, 4, 4, 4, 5, 6, 7, 7 }
1018     };
1019
1020     int index[64];
1021
1022     int av_unused last;
1023     int coeff_count = 0;
1024     int node_ctx = 0;
1025
1026     uint8_t *significant_coeff_ctx_base;
1027     uint8_t *last_coeff_ctx_base;
1028     uint8_t *abs_level_m1_ctx_base;
1029
1030 #if !ARCH_X86
1031 #define CABAC_ON_STACK
1032 #endif
1033 #ifdef CABAC_ON_STACK
1034 #define CC &cc
1035     CABACContext cc;
1036     cc.range     = h->cabac.range;
1037     cc.low       = h->cabac.low;
1038     cc.bytestream= h->cabac.bytestream;
1039 #else
1040 #define CC &h->cabac
1041 #endif
1042
1043
1044     /* cat: 0-> DC 16x16  n = 0
1045      *      1-> AC 16x16  n = luma4x4idx
1046      *      2-> Luma4x4   n = luma4x4idx
1047      *      3-> DC Chroma n = iCbCr
1048      *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1049      *      5-> Luma8x8   n = 4 * luma8x8idx
1050      */
1051
1052     /* read coded block flag */
1053     if( is_dc || cat != 5 ) {
1054         if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1055             if( !is_dc )
1056                 h->non_zero_count_cache[scan8[n]] = 0;
1057
1058 #ifdef CABAC_ON_STACK
1059             h->cabac.range     = cc.range     ;
1060             h->cabac.low       = cc.low       ;
1061             h->cabac.bytestream= cc.bytestream;
1062 #endif
1063             return;
1064         }
1065     }
1066
1067     significant_coeff_ctx_base = h->cabac_state
1068         + significant_coeff_flag_offset[MB_FIELD][cat];
1069     last_coeff_ctx_base = h->cabac_state
1070         + last_coeff_flag_offset[MB_FIELD][cat];
1071     abs_level_m1_ctx_base = h->cabac_state
1072         + coeff_abs_level_m1_offset[cat];
1073
1074     if( !is_dc && cat == 5 ) {
1075 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1076         for(last= 0; last < coefs; last++) { \
1077             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1078             if( get_cabac( CC, sig_ctx )) { \
1079                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1080                 index[coeff_count++] = last; \
1081                 if( get_cabac( CC, last_ctx ) ) { \
1082                     last= max_coeff; \
1083                     break; \
1084                 } \
1085             } \
1086         }\
1087         if( last == max_coeff -1 ) {\
1088             index[coeff_count++] = last;\
1089         }
1090         const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1091 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1092         coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1093     } else {
1094         coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1095 #else
1096         DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1097     } else {
1098         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1099 #endif
1100     }
1101     assert(coeff_count > 0);
1102
1103     if( is_dc ) {
1104         if( cat == 0 )
1105             h->cbp_table[h->mb_xy] |= 0x100;
1106         else
1107             h->cbp_table[h->mb_xy] |= 0x40 << n;
1108     } else {
1109         if( cat == 5 )
1110             fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1111         else {
1112             assert( cat == 1 || cat == 2 || cat == 4 );
1113             h->non_zero_count_cache[scan8[n]] = coeff_count;
1114         }
1115     }
1116
1117     do {
1118         uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1119
1120         int j= scantable[index[--coeff_count]];
1121
1122         if( get_cabac( CC, ctx ) == 0 ) {
1123             node_ctx = coeff_abs_level_transition[0][node_ctx];
1124             if( is_dc ) {
1125                 block[j] = get_cabac_bypass_sign( CC, -1);
1126             }else{
1127                 block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1128             }
1129         } else {
1130             int coeff_abs = 2;
1131             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1132             node_ctx = coeff_abs_level_transition[1][node_ctx];
1133
1134             while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1135                 coeff_abs++;
1136             }
1137
1138             if( coeff_abs >= 15 ) {
1139                 int j = 0;
1140                 while( get_cabac_bypass( CC ) ) {
1141                     j++;
1142                 }
1143
1144                 coeff_abs=1;
1145                 while( j-- ) {
1146                     coeff_abs += coeff_abs + get_cabac_bypass( CC );
1147                 }
1148                 coeff_abs+= 14;
1149             }
1150
1151             if( is_dc ) {
1152                 block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1153             }else{
1154                 block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1155             }
1156         }
1157     } while( coeff_count );
1158 #ifdef CABAC_ON_STACK
1159             h->cabac.range     = cc.range     ;
1160             h->cabac.low       = cc.low       ;
1161             h->cabac.bytestream= cc.bytestream;
1162 #endif
1163
1164 }
1165
1166 #if !CONFIG_SMALL
1167 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 ) {
1168     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1169 }
1170
1171 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 ) {
1172     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1173 }
1174 #endif
1175
1176 static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1177 #if CONFIG_SMALL
1178     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1179 #else
1180     if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1181     else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1182 #endif
1183 }
1184
1185 static inline void compute_mb_neighbors(H264Context *h)
1186 {
1187     MpegEncContext * const s = &h->s;
1188     const int mb_xy  = h->mb_xy;
1189     h->top_mb_xy     = mb_xy - s->mb_stride;
1190     h->left_mb_xy[0] = mb_xy - 1;
1191     if(FRAME_MBAFF){
1192         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
1193         const int top_pair_xy      = pair_xy     - s->mb_stride;
1194         const int top_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1195         const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1196         const int curr_mb_field_flag = MB_FIELD;
1197         const int bottom = (s->mb_y & 1);
1198
1199         if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1200             h->top_mb_xy -= s->mb_stride;
1201         }
1202         if (!left_mb_field_flag == curr_mb_field_flag) {
1203             h->left_mb_xy[0] = pair_xy - 1;
1204         }
1205     } else if (FIELD_PICTURE) {
1206         h->top_mb_xy -= s->mb_stride;
1207     }
1208     return;
1209 }
1210
1211 /**
1212  * decodes a macroblock
1213  * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1214  */
1215 int ff_h264_decode_mb_cabac(H264Context *h) {
1216     MpegEncContext * const s = &h->s;
1217     int mb_xy;
1218     int mb_type, partition_count, cbp = 0;
1219     int dct8x8_allowed= h->pps.transform_8x8_mode;
1220
1221     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1222
1223     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1224     if( h->slice_type_nos != FF_I_TYPE ) {
1225         int skip;
1226         /* a skipped mb needs the aff flag from the following mb */
1227         if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1228             predict_field_decoding_flag(h);
1229         if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1230             skip = h->next_mb_skipped;
1231         else
1232             skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1233         /* read skip flags */
1234         if( skip ) {
1235             if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1236                 s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1237                 h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1238                 if(!h->next_mb_skipped)
1239                     h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1240             }
1241
1242             decode_mb_skip(h);
1243
1244             h->cbp_table[mb_xy] = 0;
1245             h->chroma_pred_mode_table[mb_xy] = 0;
1246             h->last_qscale_diff = 0;
1247
1248             return 0;
1249
1250         }
1251     }
1252     if(FRAME_MBAFF){
1253         if( (s->mb_y&1) == 0 )
1254             h->mb_mbaff =
1255             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1256     }
1257
1258     h->prev_mb_skipped = 0;
1259
1260     compute_mb_neighbors(h);
1261
1262     if( h->slice_type_nos == FF_B_TYPE ) {
1263         const int mba_xy = h->left_mb_xy[0];
1264         const int mbb_xy = h->top_mb_xy;
1265         int ctx = 0;
1266         assert(h->slice_type_nos == FF_B_TYPE);
1267
1268         if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
1269             ctx++;
1270         if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
1271             ctx++;
1272
1273         if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1274             mb_type= 0; /* B_Direct_16x16 */
1275         }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1276             mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1277         }else{
1278             int bits;
1279             bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1280             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1281             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1282             bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1283             if( bits < 8 ){
1284                 mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1285             }else if( bits == 13 ){
1286                 mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1287                 goto decode_intra_mb;
1288             }else if( bits == 14 ){
1289                 mb_type= 11; /* B_L1_L0_8x16 */
1290             }else if( bits == 15 ){
1291                 mb_type= 22; /* B_8x8 */
1292             }else{
1293                 bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1294                 mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1295             }
1296         }
1297             partition_count= b_mb_type_info[mb_type].partition_count;
1298             mb_type=         b_mb_type_info[mb_type].type;
1299     } else if( h->slice_type_nos == FF_P_TYPE ) {
1300         if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1301             /* P-type */
1302             if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1303                 /* P_L0_D16x16, P_8x8 */
1304                 mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1305             } else {
1306                 /* P_L0_D8x16, P_L0_D16x8 */
1307                 mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1308             }
1309             partition_count= p_mb_type_info[mb_type].partition_count;
1310             mb_type=         p_mb_type_info[mb_type].type;
1311         } else {
1312             mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1313             goto decode_intra_mb;
1314         }
1315     } else {
1316         mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1317         if(h->slice_type == FF_SI_TYPE && mb_type)
1318             mb_type--;
1319         assert(h->slice_type_nos == FF_I_TYPE);
1320 decode_intra_mb:
1321         partition_count = 0;
1322         cbp= i_mb_type_info[mb_type].cbp;
1323         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1324         mb_type= i_mb_type_info[mb_type].type;
1325     }
1326     if(MB_FIELD)
1327         mb_type |= MB_TYPE_INTERLACED;
1328
1329     h->slice_table[ mb_xy ]= h->slice_num;
1330
1331     if(IS_INTRA_PCM(mb_type)) {
1332         const uint8_t *ptr;
1333
1334         // We assume these blocks are very rare so we do not optimize it.
1335         // FIXME The two following lines get the bitstream position in the cabac
1336         // decode, I think it should be done by a function in cabac.h (or cabac.c).
1337         ptr= h->cabac.bytestream;
1338         if(h->cabac.low&0x1) ptr--;
1339         if(CABAC_BITS==16){
1340             if(h->cabac.low&0x1FF) ptr--;
1341         }
1342
1343         // The pixels are stored in the same order as levels in h->mb array.
1344         memcpy(h->mb, ptr, 256); ptr+=256;
1345         if(CHROMA){
1346             memcpy(h->mb+128, ptr, 128); ptr+=128;
1347         }
1348
1349         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1350
1351         // All blocks are present
1352         h->cbp_table[mb_xy] = 0x1ef;
1353         h->chroma_pred_mode_table[mb_xy] = 0;
1354         // In deblocking, the quantizer is 0
1355         s->current_picture.qscale_table[mb_xy]= 0;
1356         // All coeffs are present
1357         memset(h->non_zero_count[mb_xy], 16, 32);
1358         s->current_picture.mb_type[mb_xy]= mb_type;
1359         h->last_qscale_diff = 0;
1360         return 0;
1361     }
1362
1363     if(MB_MBAFF){
1364         h->ref_count[0] <<= 1;
1365         h->ref_count[1] <<= 1;
1366     }
1367
1368     fill_decode_caches(h, mb_type);
1369
1370     if( IS_INTRA( mb_type ) ) {
1371         int i, pred_mode;
1372         if( IS_INTRA4x4( mb_type ) ) {
1373             if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1374                 mb_type |= MB_TYPE_8x8DCT;
1375                 for( i = 0; i < 16; i+=4 ) {
1376                     int pred = pred_intra_mode( h, i );
1377                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1378                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1379                 }
1380             } else {
1381                 for( i = 0; i < 16; i++ ) {
1382                     int pred = pred_intra_mode( h, i );
1383                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1384
1385                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1386                 }
1387             }
1388             ff_h264_write_back_intra_pred_mode(h);
1389             if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1390         } else {
1391             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1392             if( h->intra16x16_pred_mode < 0 ) return -1;
1393         }
1394         if(CHROMA){
1395             h->chroma_pred_mode_table[mb_xy] =
1396             pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1397
1398             pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1399             if( pred_mode < 0 ) return -1;
1400             h->chroma_pred_mode= pred_mode;
1401         }
1402     } else if( partition_count == 4 ) {
1403         int i, j, sub_partition_count[4], list, ref[2][4];
1404
1405         if( h->slice_type_nos == FF_B_TYPE ) {
1406             for( i = 0; i < 4; i++ ) {
1407                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1408                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1409                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1410             }
1411             if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1412                           h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1413                 ff_h264_pred_direct_motion(h, &mb_type);
1414                 h->ref_cache[0][scan8[4]] =
1415                 h->ref_cache[1][scan8[4]] =
1416                 h->ref_cache[0][scan8[12]] =
1417                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1418                     for( i = 0; i < 4; i++ )
1419                         fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1420             }
1421         } else {
1422             for( i = 0; i < 4; i++ ) {
1423                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1424                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1425                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1426             }
1427         }
1428
1429         for( list = 0; list < h->list_count; list++ ) {
1430                 for( i = 0; i < 4; i++ ) {
1431                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
1432                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
1433                         if( h->ref_count[list] > 1 ){
1434                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1435                             if(ref[list][i] >= (unsigned)h->ref_count[list]){
1436                                 av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1437                                 return -1;
1438                             }
1439                         }else
1440                             ref[list][i] = 0;
1441                     } else {
1442                         ref[list][i] = -1;
1443                     }
1444                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
1445                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1446                 }
1447         }
1448
1449         if(dct8x8_allowed)
1450             dct8x8_allowed = get_dct8x8_allowed(h);
1451
1452         for(list=0; list<h->list_count; list++){
1453             for(i=0; i<4; i++){
1454                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1455                 if(IS_DIRECT(h->sub_mb_type[i])){
1456                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1457                     continue;
1458                 }
1459
1460                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1461                     const int sub_mb_type= h->sub_mb_type[i];
1462                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1463                     for(j=0; j<sub_partition_count[i]; j++){
1464                         int mpx, mpy;
1465                         int mx, my;
1466                         const int index= 4*i + block_width*j;
1467                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1468                         int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1469                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1470
1471                         mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1472                         my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1473                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1474
1475                         if(IS_SUB_8X8(sub_mb_type)){
1476                             mv_cache[ 1 ][0]=
1477                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1478                             mv_cache[ 1 ][1]=
1479                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1480
1481                             mvd_cache[ 1 ][0]=
1482                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1483                             mvd_cache[ 1 ][1]=
1484                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1485                         }else if(IS_SUB_8X4(sub_mb_type)){
1486                             mv_cache[ 1 ][0]= mx;
1487                             mv_cache[ 1 ][1]= my;
1488
1489                             mvd_cache[ 1 ][0]= mx - mpx;
1490                             mvd_cache[ 1 ][1]= my - mpy;
1491                         }else if(IS_SUB_4X8(sub_mb_type)){
1492                             mv_cache[ 8 ][0]= mx;
1493                             mv_cache[ 8 ][1]= my;
1494
1495                             mvd_cache[ 8 ][0]= mx - mpx;
1496                             mvd_cache[ 8 ][1]= my - mpy;
1497                         }
1498                         mv_cache[ 0 ][0]= mx;
1499                         mv_cache[ 0 ][1]= my;
1500
1501                         mvd_cache[ 0 ][0]= mx - mpx;
1502                         mvd_cache[ 0 ][1]= my - mpy;
1503                     }
1504                 }else{
1505                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1506                     uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1507                     p[0] = p[1] = p[8] = p[9] = 0;
1508                     pd[0]= pd[1]= pd[8]= pd[9]= 0;
1509                 }
1510             }
1511         }
1512     } else if( IS_DIRECT(mb_type) ) {
1513         ff_h264_pred_direct_motion(h, &mb_type);
1514         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1515         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1516         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1517     } else {
1518         int list, mx, my, i, mpx, mpy;
1519         if(IS_16X16(mb_type)){
1520             for(list=0; list<h->list_count; list++){
1521                 if(IS_DIR(mb_type, 0, list)){
1522                     int ref;
1523                     if(h->ref_count[list] > 1){
1524                         ref= decode_cabac_mb_ref(h, list, 0);
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] ], 4, 4, 8, ref, 1);
1532                 }else
1533                     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
1534             }
1535             for(list=0; list<h->list_count; list++){
1536                 if(IS_DIR(mb_type, 0, list)){
1537                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1538
1539                     mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1540                     my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1541                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1542
1543                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1544                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1545                 }else
1546                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1547             }
1548         }
1549         else if(IS_16X8(mb_type)){
1550             for(list=0; list<h->list_count; list++){
1551                     for(i=0; i<2; i++){
1552                         if(IS_DIR(mb_type, i, list)){
1553                             int ref;
1554                             if(h->ref_count[list] > 1){
1555                                 ref= decode_cabac_mb_ref( h, list, 8*i );
1556                                 if(ref >= (unsigned)h->ref_count[list]){
1557                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1558                                     return -1;
1559                                 }
1560                             }else
1561                                 ref=0;
1562                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1563                         }else
1564                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1565                     }
1566             }
1567             for(list=0; list<h->list_count; list++){
1568                 for(i=0; i<2; i++){
1569                     if(IS_DIR(mb_type, i, list)){
1570                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1571                         mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1572                         my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1573                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1574
1575                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1576                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1577                     }else{
1578                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1579                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1580                     }
1581                 }
1582             }
1583         }else{
1584             assert(IS_8X16(mb_type));
1585             for(list=0; list<h->list_count; list++){
1586                     for(i=0; i<2; i++){
1587                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1588                             int ref;
1589                             if(h->ref_count[list] > 1){
1590                                 ref= decode_cabac_mb_ref( h, list, 4*i );
1591                                 if(ref >= (unsigned)h->ref_count[list]){
1592                                     av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1593                                     return -1;
1594                                 }
1595                             }else
1596                                 ref=0;
1597                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1598                         }else
1599                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1600                     }
1601             }
1602             for(list=0; list<h->list_count; list++){
1603                 for(i=0; i<2; i++){
1604                     if(IS_DIR(mb_type, i, list)){
1605                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1606                         mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1607                         my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1608
1609                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1610                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1611                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1612                     }else{
1613                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1614                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1615                     }
1616                 }
1617             }
1618         }
1619     }
1620
1621    if( IS_INTER( mb_type ) ) {
1622         h->chroma_pred_mode_table[mb_xy] = 0;
1623         write_back_motion( h, mb_type );
1624    }
1625
1626     if( !IS_INTRA16x16( mb_type ) ) {
1627         cbp  = decode_cabac_mb_cbp_luma( h );
1628         if(CHROMA)
1629             cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1630     }
1631
1632     h->cbp_table[mb_xy] = h->cbp = cbp;
1633
1634     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1635         mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1636     }
1637     s->current_picture.mb_type[mb_xy]= mb_type;
1638
1639     if( cbp || IS_INTRA16x16( mb_type ) ) {
1640         const uint8_t *scan, *scan8x8, *dc_scan;
1641         const uint32_t *qmul;
1642
1643         if(IS_INTERLACED(mb_type)){
1644             scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1645             scan= s->qscale ? h->field_scan : h->field_scan_q0;
1646             dc_scan= luma_dc_field_scan;
1647         }else{
1648             scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1649             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1650             dc_scan= luma_dc_zigzag_scan;
1651         }
1652
1653         // decode_cabac_mb_dqp
1654         if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1655             int val = 1;
1656             int ctx= 2;
1657
1658             while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1659                 ctx= 3;
1660                 val++;
1661                 if(val > 102){ //prevent infinite loop
1662                     av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1663                     return -1;
1664                 }
1665             }
1666
1667             if( val&0x01 )
1668                 val=   (val + 1)>>1 ;
1669             else
1670                 val= -((val + 1)>>1);
1671             h->last_qscale_diff = val;
1672             s->qscale += val;
1673             if(((unsigned)s->qscale) > 51){
1674                 if(s->qscale<0) s->qscale+= 52;
1675                 else            s->qscale-= 52;
1676             }
1677             h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1678             h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1679         }else
1680             h->last_qscale_diff=0;
1681
1682         if( IS_INTRA16x16( mb_type ) ) {
1683             int i;
1684             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1685             decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1686
1687             if( cbp&15 ) {
1688                 qmul = h->dequant4_coeff[0][s->qscale];
1689                 for( i = 0; i < 16; i++ ) {
1690                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1691                     decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1692                 }
1693             } else {
1694                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1695             }
1696         } else {
1697             int i8x8, i4x4;
1698             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1699                 if( cbp & (1<<i8x8) ) {
1700                     if( IS_8x8DCT(mb_type) ) {
1701                         decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1702                             scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1703                     } else {
1704                         qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1705                         for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1706                             const int index = 4*i8x8 + i4x4;
1707                             //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1708 //START_TIMER
1709                             decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1710 //STOP_TIMER("decode_residual")
1711                         }
1712                     }
1713                 } else {
1714                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1715                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1716                 }
1717             }
1718         }
1719
1720         if( cbp&0x30 ){
1721             int c;
1722             for( c = 0; c < 2; c++ ) {
1723                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1724                 decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1725             }
1726         }
1727
1728         if( cbp&0x20 ) {
1729             int c, i;
1730             for( c = 0; c < 2; c++ ) {
1731                 qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1732                 for( i = 0; i < 4; i++ ) {
1733                     const int index = 16 + 4 * c + i;
1734                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1735                     decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1736                 }
1737             }
1738         } else {
1739             uint8_t * const nnz= &h->non_zero_count_cache[0];
1740             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1741             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1742         }
1743     } else {
1744         uint8_t * const nnz= &h->non_zero_count_cache[0];
1745         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1746         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1747         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1748         h->last_qscale_diff = 0;
1749     }
1750
1751     s->current_picture.qscale_table[mb_xy]= s->qscale;
1752     write_back_non_zero_count(h);
1753
1754     if(MB_MBAFF){
1755         h->ref_count[0] >>= 1;
1756         h->ref_count[1] >>= 1;
1757     }
1758
1759     return 0;
1760 }