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