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