Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ 05307427

History | View | Annotate | Download (71.8 KB)

1
/*
2
 * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
3
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file libavcodec/h264_cabac.c
24
 * H.264 / AVC / MPEG4 part10 cabac decoding.
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 */
27

    
28
#define CABAC 1
29

    
30
#include "internal.h"
31
#include "dsputil.h"
32
#include "avcodec.h"
33
#include "h264.h"
34
#include "h264data.h"
35
#include "h264_mvpred.h"
36
#include "golomb.h"
37

    
38
#include "cabac.h"
39
#if ARCH_X86
40
#include "x86/h264_i386.h"
41
#endif
42

    
43
//#undef NDEBUG
44
#include <assert.h>
45

    
46
/* Cabac pre state table */
47

    
48
static const int8_t cabac_context_init_I[460][2] =
49
{
50
    /* 0 - 10 */
51
    { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },
52
    {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },
53
    { -6,  53 }, { -1, 54 },  {  7,  51 },
54

    
55
    /* 11 - 23 unsused for I */
56
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
57
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
58
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
59
    { 0, 0 },
60

    
61
    /* 24- 39 */
62
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
63
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
64
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
65
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
66

    
67
    /* 40 - 53 */
68
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
69
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
70
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
71
    { 0, 0 },    { 0, 0 },
72

    
73
    /* 54 - 59 */
74
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
75
    { 0, 0 },    { 0, 0 },
76

    
77
    /* 60 - 69 */
78
    { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
79
    { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
80
    { 13, 41 },  { 3, 62 },
81

    
82
    /* 70 -> 87 */
83
    { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },
84
    { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },
85
    { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },
86
    { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },
87
    { -12, 115 },{ -16, 122 },
88

    
89
    /* 88 -> 104 */
90
    { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },
91
    { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },
92
    { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },
93
    { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },
94
    { -22, 125 },
95

    
96
    /* 105 -> 135 */
97
    { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },
98
    { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },
99
    { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },
100
    { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },
101
    { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },
102
    { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },
103
    { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },
104
    { 14, 62 },  { -13, 108 },{ -15, 100 },
105

    
106
    /* 136 -> 165 */
107
    { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },
108
    { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },
109
    { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },
110
    { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },
111
    { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },
112
    { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },
113
    { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },
114
    { 0, 62 },   { 12, 72 },
115

    
116
    /* 166 -> 196 */
117
    { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },
118
    { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },
119
    { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },
120
    { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },
121
    { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },
122
    { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },
123
    { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },
124
    { 0, 89 },   { 26, -19 }, { 22, -17 },
125

    
126
    /* 197 -> 226 */
127
    { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },
128
    { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },
129
    { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },
130
    { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },
131
    { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },
132
    { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },
133
    { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },
134
    { 12, 68 },  { 2, 97 },
135

    
136
    /* 227 -> 251 */
137
    { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },
138
    { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },
139
    { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },
140
    { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },
141
    { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },
142
    { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },
143
    { -4, 65 },
144

    
145
    /* 252 -> 275 */
146
    { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },
147
    { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },
148
    { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },
149
    { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },
150
    { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },
151
    { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },
152

    
153
    /* 276 a bit special (not used, bypass is used instead) */
154
    { 0, 0 },
155

    
156
    /* 277 -> 307 */
157
    { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },
158
    { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },
159
    { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },
160
    { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },
161
    { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },
162
    { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },
163
    { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },
164
    { 9, 64 },   { -12, 104 },{ -11, 97 },
165

    
166
    /* 308 -> 337 */
167
    { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },
168
    { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },
169
    { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },
170
    { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },
171
    { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },
172
    { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },
173
    { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },
174
    { 5, 64 },   { 12, 70 },
175

    
176
    /* 338 -> 368 */
177
    { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },
178
    { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },
179
    { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },
180
    { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },
181
    { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },
182
    { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },
183
    { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },
184
    { -12, 109 },{ 36, -35 }, { 36, -34 },
185

    
186
    /* 369 -> 398 */
187
    { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },
188
    { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },
189
    { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },
190
    { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },
191
    { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },
192
    { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },
193
    { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },
194
    { 29, 39 },  { 19, 66 },
195

    
196
    /* 399 -> 435 */
197
    {  31,  21 }, {  31,  31 }, {  25,  50 },
198
    { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },
199
    { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },
200
    { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },
201
    { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },
202
    {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },
203
    {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },
204
    {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },
205
    {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },
206
    {   0,  68 }, {  -9,  92 },
207

    
208
    /* 436 -> 459 */
209
    { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },
210
    { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },
211
    { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },
212
    {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },
213
    {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },
214
    {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }
215
};
216

    
217
static const int8_t cabac_context_init_PB[3][460][2] =
218
{
219
    /* i_cabac_init_idc == 0 */
220
    {
221
        /* 0 - 10 */
222
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
223
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
224
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
225

    
226
        /* 11 - 23 */
227
        {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },
228
        {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },
229
        { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },
230
        {  17,  50 },
231

    
232
        /* 24 - 39 */
233
        {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },
234
        {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },
235
        {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },
236
        {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },
237

    
238
        /* 40 - 53 */
239
        {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },
240
        {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },
241
        {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },
242
        {  -3,  81 }, {   0,  88 },
243

    
244
        /* 54 - 59 */
245
        {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },
246
        {  -7,  72 }, {   1,  58 },
247

    
248
        /* 60 - 69 */
249
        {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },
250
        {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },
251
        {  13,  41 }, {   3,  62 },
252

    
253
        /* 70 - 87 */
254
        {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },
255
        { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },
256
        { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },
257
        { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },
258
        {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },
259
        {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },
260
        {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },
261
        {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },
262
        {   0,  68 }, {  -4,  69 }, {  -8,  88 },
263

    
264
        /* 105 -> 165 */
265
        {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },
266
        {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },
267
        {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },
268
        {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },
269
        {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },
270
        {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },
271
        {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },
272
        {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },
273
        {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },
274
        {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },
275
        {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },
276
        {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },
277
        {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },
278
        {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },
279
        {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },
280
        {   9,  69 },
281

    
282
        /* 166 - 226 */
283
        {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },
284
        {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },
285
        {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },
286
        {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },
287
        {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },
288
        {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },
289
        {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },
290
        {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },
291
        {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },
292
        {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },
293
        {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },
294
        {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },
295
        {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },
296
        {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },
297
        {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },
298
        {  -9, 108 },
299

    
300
        /* 227 - 275 */
301
        {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },
302
        {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },
303
        {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },
304
        {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },
305
        {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },
306
        {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },
307
        {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },
308
        {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },
309
        {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },
310
        {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },
311
        {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },
312
        {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },
313
        {  -8,  85 },
314

    
315
        /* 276 a bit special (not used, bypass is used instead) */
316
        { 0, 0 },
317

    
318
        /* 277 - 337 */
319
        { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },
320
        { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },
321
        { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
322
        { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },
323
        { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },
324
        { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },
325
        {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },
326
        {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },
327
        {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },
328
        {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },
329
        {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },
330
        {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },
331
        {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },
332
        {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },
333
        {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },
334
        {  26,  43 },
335

    
336
        /* 338 - 398 */
337
        {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },
338
        {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },
339
        {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },
340
        {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },
341
        {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },
342
        {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },
343
        {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },
344
        { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },
345
        {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },
346
        {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },
347
        {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },
348
        {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },
349
        {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },
350
        {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },
351
        {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },
352
        {  11,  86 },
353

    
354
        /* 399 - 435 */
355
        {  12,  40 }, {  11,  51 }, {  14,  59 },
356
        {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },
357
        {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },
358
        { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },
359
        { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },
360
        {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },
361
        {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },
362
        {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },
363
        {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },
364
        {  -8,  66 }, {  -8,  76 },
365

    
366
        /* 436 - 459 */
367
        {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
368
        { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
369
        {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
370
        { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },
371
        {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },
372
        {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },
373
    },
374

    
375
    /* i_cabac_init_idc == 1 */
376
    {
377
        /* 0 - 10 */
378
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
379
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
380
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
381

    
382
        /* 11 - 23 */
383
        {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },
384
        {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },
385
        { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },
386
        {  10,  54 },
387

    
388
        /* 24 - 39 */
389
        {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },
390
        {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },
391
        {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },
392
        {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },
393

    
394
        /* 40 - 53 */
395
        {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },
396
        {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },
397
        {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },
398
        {  -7,  86 },{  -5,  95 },
399

    
400
        /* 54 - 59 */
401
        {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },
402
        {  -5,  72 },{   0,  61 },
403

    
404
        /* 60 - 69 */
405
        { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
406
        { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
407
        { 13, 41 },  { 3, 62 },
408

    
409
        /* 70 - 104 */
410
        {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },
411
        { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },
412
        { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },
413
        { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },
414
        {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },
415
        {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },
416
        { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },
417
        {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },
418
        {   0,  68 }, {  -7,  74 }, {  -9,  88 },
419

    
420
        /* 105 -> 165 */
421
        { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },
422
        {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },
423
        { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },
424
        { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },
425
        {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },
426
        {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },
427
        { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },
428
        { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },
429
        {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },
430
        { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },
431
        {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },
432
        {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },
433
        {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },
434
        {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },
435
        {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },
436
        {   0,  89 },
437

    
438
        /* 166 - 226 */
439
        {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },
440
        {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },
441
        {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },
442
        { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },
443
        {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },
444
        {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },
445
        {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },
446
        {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },
447
        {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },
448
        {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },
449
        {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },
450
        {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },
451
        {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },
452
        {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },
453
        {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },
454
        { -10, 116 },
455

    
456
        /* 227 - 275 */
457
        { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },
458
        {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },
459
        { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },
460
        {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },
461
        { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
462
        { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },
463
        {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },
464
        {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },
465
        {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },
466
        {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },
467
        {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },
468
        {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },
469
        {  -4,  78 },
470

    
471
        /* 276 a bit special (not used, bypass is used instead) */
472
        { 0, 0 },
473

    
474
        /* 277 - 337 */
475
        { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
476
        { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
477
        { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
478
        { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },
479
        { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },
480
        {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },
481
        {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },
482
        {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },
483
        {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },
484
        {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },
485
        {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },
486
        {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },
487
        {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },
488
        {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },
489
        {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },
490
        {  18,  50 },
491

    
492
        /* 338 - 398 */
493
        {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },
494
        {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },
495
        {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },
496
        {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },
497
        {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },
498
        {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },
499
        {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },
500
        {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },
501
        {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },
502
        {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },
503
        {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },
504
        {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },
505
        {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },
506
        {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },
507
        {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },
508
        {  11,  83 },
509

    
510
        /* 399 - 435 */
511
        {  25,  32 }, {  21,  49 }, {  21,  54 },
512
        {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
513
        { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
514
        {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
515
        { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },
516
        {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
517
        {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
518
        {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },
519
        {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },
520
        {  -4,  67 }, {  -7,  82 },
521

    
522
        /* 436 - 459 */
523
        {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },
524
        { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },
525
        {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },
526
        {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },
527
        {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
528
        {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
529
    },
530

    
531
    /* i_cabac_init_idc == 2 */
532
    {
533
        /* 0 - 10 */
534
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
535
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
536
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
537

    
538
        /* 11 - 23 */
539
        {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },
540
        {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },
541
        { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },
542
        {  14,  57 },
543

    
544
        /* 24 - 39 */
545
        {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },
546
        {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },
547
        {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },
548
        {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },
549

    
550
        /* 40 - 53 */
551
        { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },
552
        {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },
553
        {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },
554
        {  -3,  90 },{  -1,  101 },
555

    
556
        /* 54 - 59 */
557
        {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },
558
        {  -7,  50 },{   1,  60 },
559

    
560
        /* 60 - 69 */
561
        { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
562
        { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
563
        { 13, 41 },  { 3, 62 },
564

    
565
        /* 70 - 104 */
566
        {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },
567
        { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },
568
        { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },
569
        { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },
570
        {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },
571
        {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },
572
        { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },
573
        {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },
574
        {   3,  68 }, {  -8,  71 }, { -13,  98 },
575

    
576
        /* 105 -> 165 */
577
        {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },
578
        {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },
579
        {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },
580
        {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },
581
        {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },
582
        {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },
583
        {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },
584
        {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },
585
        {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },
586
        { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },
587
        {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },
588
        {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },
589
        {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },
590
        {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },
591
        { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },
592
        { -22, 127 },
593

    
594
        /* 166 - 226 */
595
        {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },
596
        {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },
597
        {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },
598
        {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },
599
        {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },
600
        {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },
601
        {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },
602
        {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },
603
        {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },
604
        {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },
605
        {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },
606
        {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },
607
        {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },
608
        {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },
609
        {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },
610
        { -24, 127 },
611

    
612
        /* 227 - 275 */
613
        { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },
614
        {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },
615
        { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },
616
        { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },
617
        { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },
618
        { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },
619
        {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },
620
        { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },
621
        { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },
622
        {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },
623
        {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },
624
        { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },
625
        { -10,  87 },
626

    
627
        /* 276 a bit special (not used, bypass is used instead) */
628
        { 0, 0 },
629

    
630
        /* 277 - 337 */
631
        { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
632
        { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
633
        { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
634
        { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },
635
        { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },
636
        { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },
637
        {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },
638
        {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },
639
        {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },
640
        {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },
641
        {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },
642
        {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },
643
        { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },
644
        {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },
645
        {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },
646
        {  25,  42 },
647

    
648
        /* 338 - 398 */
649
        {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },
650
        {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },
651
        {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },
652
        {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },
653
        {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },
654
        {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },
655
        {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },
656
        {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },
657
        {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },
658
        {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },
659
        {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },
660
        {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },
661
        {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },
662
        {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },
663
        {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },
664
        {  25,  61 },
665

    
666
        /* 399 - 435 */
667
        {  21,  33 }, {  19,  50 }, {  17,  61 },
668
        {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
669
        { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
670
        { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
671
        { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
672
        {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
673
        {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
674
        {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },
675
        { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },
676
        {  -6,  68 }, { -10,  79 },
677

    
678
        /* 436 - 459 */
679
        {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
680
        { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
681
        { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
682
        { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
683
        {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
684
        {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
685
    }
686
};
687

    
688
void ff_h264_init_cabac_states(H264Context *h) {
689
    MpegEncContext * const s = &h->s;
690
    int i;
691

    
692
    /* calculate pre-state */
693
    for( i= 0; i < 460; i++ ) {
694
        int pre;
695
        if( h->slice_type_nos == FF_I_TYPE )
696
            pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
697
        else
698
            pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
699

    
700
        if( pre <= 63 )
701
            h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
702
        else
703
            h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
704
    }
705
}
706

    
707
static int decode_cabac_field_decoding_flag(H264Context *h) {
708
    MpegEncContext * const s = &h->s;
709
    const long mba_xy = h->mb_xy - 1L;
710
    const long mbb_xy = h->mb_xy - 2L*s->mb_stride;
711

    
712
    unsigned long ctx = 0;
713

    
714
    ctx += (s->current_picture.mb_type[mba_xy]>>7)&(h->slice_table[mba_xy] == h->slice_num);
715
    ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
716

    
717
    return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
718
}
719

    
720
static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
721
    uint8_t *state= &h->cabac_state[ctx_base];
722
    int mb_type;
723

    
724
    if(intra_slice){
725
        MpegEncContext * const s = &h->s;
726
        const int mba_xy = h->left_mb_xy[0];
727
        const int mbb_xy = h->top_mb_xy;
728
        int ctx=0;
729
        if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
730
            ctx++;
731
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
732
            ctx++;
733
        if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
734
            return 0;   /* I4x4 */
735
        state += 2;
736
    }else{
737
        if( get_cabac_noinline( &h->cabac, state ) == 0 )
738
            return 0;   /* I4x4 */
739
    }
740

    
741
    if( get_cabac_terminate( &h->cabac ) )
742
        return 25;  /* PCM */
743

    
744
    mb_type = 1; /* I16x16 */
745
    mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
746
    if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
747
        mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
748
    mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
749
    mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
750
    return mb_type;
751
}
752

    
753
static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
754
    MpegEncContext * const s = &h->s;
755
    int mba_xy, mbb_xy;
756
    int ctx = 0;
757

    
758
    if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
759
        int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
760
        mba_xy = mb_xy - 1;
761
        if( (mb_y&1)
762
            && h->slice_table[mba_xy] == h->slice_num
763
            && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
764
            mba_xy += s->mb_stride;
765
        if( MB_FIELD ){
766
            mbb_xy = mb_xy - s->mb_stride;
767
            if( !(mb_y&1)
768
                && h->slice_table[mbb_xy] == h->slice_num
769
                && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
770
                mbb_xy -= s->mb_stride;
771
        }else
772
            mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
773
    }else{
774
        int mb_xy = h->mb_xy;
775
        mba_xy = mb_xy - 1;
776
        mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
777
    }
778

    
779
    if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
780
        ctx++;
781
    if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
782
        ctx++;
783

    
784
    if( h->slice_type_nos == FF_B_TYPE )
785
        ctx += 13;
786
    return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
787
}
788

    
789
static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
790
    int mode = 0;
791

    
792
    if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
793
        return pred_mode;
794

    
795
    mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
796
    mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
797
    mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
798

    
799
    return mode + ( mode >= pred_mode );
800
}
801

    
802
static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
803
    const int mba_xy = h->left_mb_xy[0];
804
    const int mbb_xy = h->top_mb_xy;
805

    
806
    int ctx = 0;
807

    
808
    /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
809
    if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
810
        ctx++;
811

    
812
    if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
813
        ctx++;
814

    
815
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
816
        return 0;
817

    
818
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
819
        return 1;
820
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
821
        return 2;
822
    else
823
        return 3;
824
}
825

    
826
static int decode_cabac_mb_cbp_luma( H264Context *h) {
827
    int cbp_b, cbp_a, ctx, cbp = 0;
828

    
829
    cbp_a = h->left_cbp;
830
    cbp_b = h->top_cbp;
831

    
832
    ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
833
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
834
    ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
835
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
836
    ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
837
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
838
    ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
839
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
840
    return cbp;
841
}
842
static int decode_cabac_mb_cbp_chroma( H264Context *h) {
843
    int ctx;
844
    int cbp_a, cbp_b;
845

    
846
    cbp_a = (h->left_cbp>>4)&0x03;
847
    cbp_b = (h-> top_cbp>>4)&0x03;
848

    
849
    ctx = 0;
850
    if( cbp_a > 0 ) ctx++;
851
    if( cbp_b > 0 ) ctx += 2;
852
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
853
        return 0;
854

    
855
    ctx = 4;
856
    if( cbp_a == 2 ) ctx++;
857
    if( cbp_b == 2 ) ctx += 2;
858
    return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
859
}
860

    
861
static int decode_cabac_p_mb_sub_type( H264Context *h ) {
862
    if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
863
        return 0;   /* 8x8 */
864
    if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
865
        return 1;   /* 8x4 */
866
    if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
867
        return 2;   /* 4x8 */
868
    return 3;       /* 4x4 */
869
}
870
static int decode_cabac_b_mb_sub_type( H264Context *h ) {
871
    int type;
872
    if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
873
        return 0;   /* B_Direct_8x8 */
874
    if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
875
        return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
876
    type = 3;
877
    if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
878
        if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
879
            return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
880
        type += 4;
881
    }
882
    type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
883
    type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
884
    return type;
885
}
886

    
887
static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
888
    int refa = h->ref_cache[list][scan8[n] - 1];
889
    int refb = h->ref_cache[list][scan8[n] - 8];
890
    int ref  = 0;
891
    int ctx  = 0;
892

    
893
    if( h->slice_type_nos == FF_B_TYPE) {
894
        if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
895
            ctx++;
896
        if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
897
            ctx += 2;
898
    } else {
899
        if( refa > 0 )
900
            ctx++;
901
        if( refb > 0 )
902
            ctx += 2;
903
    }
904

    
905
    while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
906
        ref++;
907
        ctx = (ctx>>2)+4;
908
        if(ref >= 32 /*h->ref_list[list]*/){
909
            return -1;
910
        }
911
    }
912
    return ref;
913
}
914

    
915
static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
916
    int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
917
               abs( h->mvd_cache[list][scan8[n] - 8][l] );
918
    int ctxbase = (l == 0) ? 40 : 47;
919
    int mvd;
920
    int ctx = (amvd>2) + (amvd>32);
921

    
922
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
923
        return 0;
924

    
925
    mvd= 1;
926
    ctx= 3;
927
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
928
        mvd++;
929
        if( ctx < 6 )
930
            ctx++;
931
    }
932

    
933
    if( mvd >= 9 ) {
934
        int k = 3;
935
        while( get_cabac_bypass( &h->cabac ) ) {
936
            mvd += 1 << k;
937
            k++;
938
            if(k>24){
939
                av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
940
                return INT_MIN;
941
            }
942
        }
943
        while( k-- ) {
944
            if( get_cabac_bypass( &h->cabac ) )
945
                mvd += 1 << k;
946
        }
947
    }
948
    return get_cabac_bypass_sign( &h->cabac, -mvd );
949
}
950

    
951
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
952
    int nza, nzb;
953
    int ctx = 0;
954

    
955
    if( is_dc ) {
956
        if( cat == 0 ) {
957
            nza = h->left_cbp&0x100;
958
            nzb = h-> top_cbp&0x100;
959
        } else {
960
            nza = (h->left_cbp>>(6+idx))&0x01;
961
            nzb = (h-> top_cbp>>(6+idx))&0x01;
962
        }
963
    } else {
964
        assert(cat == 1 || cat == 2 || cat == 4);
965
        nza = h->non_zero_count_cache[scan8[idx] - 1];
966
        nzb = h->non_zero_count_cache[scan8[idx] - 8];
967
    }
968

    
969
    if( nza > 0 )
970
        ctx++;
971

    
972
    if( nzb > 0 )
973
        ctx += 2;
974

    
975
    return ctx + 4 * cat;
976
}
977

    
978
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
979
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
980
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
981
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
982
    5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
983
};
984

    
985
static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
986
    static const int significant_coeff_flag_offset[2][6] = {
987
      { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
988
      { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
989
    };
990
    static const int last_coeff_flag_offset[2][6] = {
991
      { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
992
      { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
993
    };
994
    static const int coeff_abs_level_m1_offset[6] = {
995
        227+0, 227+10, 227+20, 227+30, 227+39, 426
996
    };
997
    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
998
      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
999
        4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1000
        7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1001
       12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1002
      { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1003
        6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1004
        9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1005
        9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1006
    };
1007
    /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1008
     * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1009
     * map node ctx => cabac ctx for level=1 */
1010
    static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1011
    /* map node ctx => cabac ctx for level>1 */
1012
    static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1013
    static const uint8_t coeff_abs_level_transition[2][8] = {
1014
    /* update node ctx after decoding a level=1 */
1015
        { 1, 2, 3, 3, 4, 5, 6, 7 },
1016
    /* update node ctx after decoding a level>1 */
1017
        { 4, 4, 4, 4, 5, 6, 7, 7 }
1018
    };
1019

    
1020
    int index[64];
1021

    
1022
    int av_unused last;
1023
    int coeff_count = 0;
1024
    int node_ctx = 0;
1025

    
1026
    uint8_t *significant_coeff_ctx_base;
1027
    uint8_t *last_coeff_ctx_base;
1028
    uint8_t *abs_level_m1_ctx_base;
1029

    
1030
#if !ARCH_X86
1031
#define CABAC_ON_STACK
1032
#endif
1033
#ifdef CABAC_ON_STACK
1034
#define CC &cc
1035
    CABACContext cc;
1036
    cc.range     = h->cabac.range;
1037
    cc.low       = h->cabac.low;
1038
    cc.bytestream= h->cabac.bytestream;
1039
#else
1040
#define CC &h->cabac
1041
#endif
1042

    
1043

    
1044
    /* cat: 0-> DC 16x16  n = 0
1045
     *      1-> AC 16x16  n = luma4x4idx
1046
     *      2-> Luma4x4   n = luma4x4idx
1047
     *      3-> DC Chroma n = iCbCr
1048
     *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1049
     *      5-> Luma8x8   n = 4 * luma8x8idx
1050
     */
1051

    
1052
    /* read coded block flag */
1053
    if( is_dc || cat != 5 ) {
1054
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1055
            if( !is_dc )
1056
                h->non_zero_count_cache[scan8[n]] = 0;
1057

    
1058
#ifdef CABAC_ON_STACK
1059
            h->cabac.range     = cc.range     ;
1060
            h->cabac.low       = cc.low       ;
1061
            h->cabac.bytestream= cc.bytestream;
1062
#endif
1063
            return;
1064
        }
1065
    }
1066

    
1067
    significant_coeff_ctx_base = h->cabac_state
1068
        + significant_coeff_flag_offset[MB_FIELD][cat];
1069
    last_coeff_ctx_base = h->cabac_state
1070
        + last_coeff_flag_offset[MB_FIELD][cat];
1071
    abs_level_m1_ctx_base = h->cabac_state
1072
        + coeff_abs_level_m1_offset[cat];
1073

    
1074
    if( !is_dc && cat == 5 ) {
1075
#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1076
        for(last= 0; last < coefs; last++) { \
1077
            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1078
            if( get_cabac( CC, sig_ctx )) { \
1079
                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1080
                index[coeff_count++] = last; \
1081
                if( get_cabac( CC, last_ctx ) ) { \
1082
                    last= max_coeff; \
1083
                    break; \
1084
                } \
1085
            } \
1086
        }\
1087
        if( last == max_coeff -1 ) {\
1088
            index[coeff_count++] = last;\
1089
        }
1090
        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1091
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1092
        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1093
    } else {
1094
        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1095
#else
1096
        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1097
    } else {
1098
        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1099
#endif
1100
    }
1101
    assert(coeff_count > 0);
1102

    
1103
    if( is_dc ) {
1104
        if( cat == 0 )
1105
            h->cbp_table[h->mb_xy] |= 0x100;
1106
        else
1107
            h->cbp_table[h->mb_xy] |= 0x40 << n;
1108
    } else {
1109
        if( cat == 5 )
1110
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1111
        else {
1112
            assert( cat == 1 || cat == 2 || cat == 4 );
1113
            h->non_zero_count_cache[scan8[n]] = coeff_count;
1114
        }
1115
    }
1116

    
1117
    do {
1118
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1119

    
1120
        int j= scantable[index[--coeff_count]];
1121

    
1122
        if( get_cabac( CC, ctx ) == 0 ) {
1123
            node_ctx = coeff_abs_level_transition[0][node_ctx];
1124
            if( is_dc ) {
1125
                block[j] = get_cabac_bypass_sign( CC, -1);
1126
            }else{
1127
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1128
            }
1129
        } else {
1130
            int coeff_abs = 2;
1131
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1132
            node_ctx = coeff_abs_level_transition[1][node_ctx];
1133

    
1134
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1135
                coeff_abs++;
1136
            }
1137

    
1138
            if( coeff_abs >= 15 ) {
1139
                int j = 0;
1140
                while( get_cabac_bypass( CC ) ) {
1141
                    j++;
1142
                }
1143

    
1144
                coeff_abs=1;
1145
                while( j-- ) {
1146
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
1147
                }
1148
                coeff_abs+= 14;
1149
            }
1150

    
1151
            if( is_dc ) {
1152
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1153
            }else{
1154
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1155
            }
1156
        }
1157
    } while( coeff_count );
1158
#ifdef CABAC_ON_STACK
1159
            h->cabac.range     = cc.range     ;
1160
            h->cabac.low       = cc.low       ;
1161
            h->cabac.bytestream= cc.bytestream;
1162
#endif
1163

    
1164
}
1165

    
1166
#if !CONFIG_SMALL
1167
static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1168
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1169
}
1170

    
1171
static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1172
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1173
}
1174
#endif
1175

    
1176
static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1177
#if CONFIG_SMALL
1178
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1179
#else
1180
    if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1181
    else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1182
#endif
1183
}
1184

    
1185
/**
1186
 * decodes a macroblock
1187
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1188
 */
1189
int ff_h264_decode_mb_cabac(H264Context *h) {
1190
    MpegEncContext * const s = &h->s;
1191
    int mb_xy;
1192
    int mb_type, partition_count, cbp = 0;
1193
    int dct8x8_allowed= h->pps.transform_8x8_mode;
1194

    
1195
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1196

    
1197
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1198
    if( h->slice_type_nos != FF_I_TYPE ) {
1199
        int skip;
1200
        /* a skipped mb needs the aff flag from the following mb */
1201
        if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1202
            predict_field_decoding_flag(h);
1203
        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1204
            skip = h->next_mb_skipped;
1205
        else
1206
            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1207
        /* read skip flags */
1208
        if( skip ) {
1209
            if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1210
                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1211
                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1212
                if(!h->next_mb_skipped)
1213
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1214
            }
1215

    
1216
            decode_mb_skip(h);
1217

    
1218
            h->cbp_table[mb_xy] = 0;
1219
            h->chroma_pred_mode_table[mb_xy] = 0;
1220
            h->last_qscale_diff = 0;
1221

    
1222
            return 0;
1223

    
1224
        }
1225
    }
1226
    if(FRAME_MBAFF){
1227
        if( (s->mb_y&1) == 0 )
1228
            h->mb_mbaff =
1229
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1230
    }
1231

    
1232
    h->prev_mb_skipped = 0;
1233

    
1234
    fill_decode_neighbors(h, -(MB_FIELD));
1235

    
1236
    if( h->slice_type_nos == FF_B_TYPE ) {
1237
        const int mba_xy = h->left_mb_xy[0];
1238
        const int mbb_xy = h->top_mb_xy;
1239
        int ctx = 0;
1240
        assert(h->slice_type_nos == FF_B_TYPE);
1241

    
1242
        if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
1243
            ctx++;
1244
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
1245
            ctx++;
1246

    
1247
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1248
            mb_type= 0; /* B_Direct_16x16 */
1249
        }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1250
            mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1251
        }else{
1252
            int bits;
1253
            bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1254
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1255
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1256
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1257
            if( bits < 8 ){
1258
                mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1259
            }else if( bits == 13 ){
1260
                mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1261
                goto decode_intra_mb;
1262
            }else if( bits == 14 ){
1263
                mb_type= 11; /* B_L1_L0_8x16 */
1264
            }else if( bits == 15 ){
1265
                mb_type= 22; /* B_8x8 */
1266
            }else{
1267
                bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1268
                mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1269
            }
1270
        }
1271
            partition_count= b_mb_type_info[mb_type].partition_count;
1272
            mb_type=         b_mb_type_info[mb_type].type;
1273
    } else if( h->slice_type_nos == FF_P_TYPE ) {
1274
        if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1275
            /* P-type */
1276
            if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1277
                /* P_L0_D16x16, P_8x8 */
1278
                mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1279
            } else {
1280
                /* P_L0_D8x16, P_L0_D16x8 */
1281
                mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1282
            }
1283
            partition_count= p_mb_type_info[mb_type].partition_count;
1284
            mb_type=         p_mb_type_info[mb_type].type;
1285
        } else {
1286
            mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1287
            goto decode_intra_mb;
1288
        }
1289
    } else {
1290
        mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1291
        if(h->slice_type == FF_SI_TYPE && mb_type)
1292
            mb_type--;
1293
        assert(h->slice_type_nos == FF_I_TYPE);
1294
decode_intra_mb:
1295
        partition_count = 0;
1296
        cbp= i_mb_type_info[mb_type].cbp;
1297
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1298
        mb_type= i_mb_type_info[mb_type].type;
1299
    }
1300
    if(MB_FIELD)
1301
        mb_type |= MB_TYPE_INTERLACED;
1302

    
1303
    h->slice_table[ mb_xy ]= h->slice_num;
1304

    
1305
    if(IS_INTRA_PCM(mb_type)) {
1306
        const uint8_t *ptr;
1307

    
1308
        // We assume these blocks are very rare so we do not optimize it.
1309
        // FIXME The two following lines get the bitstream position in the cabac
1310
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
1311
        ptr= h->cabac.bytestream;
1312
        if(h->cabac.low&0x1) ptr--;
1313
        if(CABAC_BITS==16){
1314
            if(h->cabac.low&0x1FF) ptr--;
1315
        }
1316

    
1317
        // The pixels are stored in the same order as levels in h->mb array.
1318
        memcpy(h->mb, ptr, 256); ptr+=256;
1319
        if(CHROMA){
1320
            memcpy(h->mb+128, ptr, 128); ptr+=128;
1321
        }
1322

    
1323
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1324

    
1325
        // All blocks are present
1326
        h->cbp_table[mb_xy] = 0x1ef;
1327
        h->chroma_pred_mode_table[mb_xy] = 0;
1328
        // In deblocking, the quantizer is 0
1329
        s->current_picture.qscale_table[mb_xy]= 0;
1330
        // All coeffs are present
1331
        memset(h->non_zero_count[mb_xy], 16, 32);
1332
        s->current_picture.mb_type[mb_xy]= mb_type;
1333
        h->last_qscale_diff = 0;
1334
        return 0;
1335
    }
1336

    
1337
    if(MB_MBAFF){
1338
        h->ref_count[0] <<= 1;
1339
        h->ref_count[1] <<= 1;
1340
    }
1341

    
1342
    fill_decode_caches(h, mb_type);
1343

    
1344
    if( IS_INTRA( mb_type ) ) {
1345
        int i, pred_mode;
1346
        if( IS_INTRA4x4( mb_type ) ) {
1347
            if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1348
                mb_type |= MB_TYPE_8x8DCT;
1349
                for( i = 0; i < 16; i+=4 ) {
1350
                    int pred = pred_intra_mode( h, i );
1351
                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1352
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1353
                }
1354
            } else {
1355
                for( i = 0; i < 16; i++ ) {
1356
                    int pred = pred_intra_mode( h, i );
1357
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1358

    
1359
                //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1360
                }
1361
            }
1362
            ff_h264_write_back_intra_pred_mode(h);
1363
            if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1364
        } else {
1365
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1366
            if( h->intra16x16_pred_mode < 0 ) return -1;
1367
        }
1368
        if(CHROMA){
1369
            h->chroma_pred_mode_table[mb_xy] =
1370
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1371

    
1372
            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1373
            if( pred_mode < 0 ) return -1;
1374
            h->chroma_pred_mode= pred_mode;
1375
        }
1376
    } else if( partition_count == 4 ) {
1377
        int i, j, sub_partition_count[4], list, ref[2][4];
1378

    
1379
        if( h->slice_type_nos == FF_B_TYPE ) {
1380
            for( i = 0; i < 4; i++ ) {
1381
                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1382
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1383
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1384
            }
1385
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1386
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1387
                ff_h264_pred_direct_motion(h, &mb_type);
1388
                h->ref_cache[0][scan8[4]] =
1389
                h->ref_cache[1][scan8[4]] =
1390
                h->ref_cache[0][scan8[12]] =
1391
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1392
                    for( i = 0; i < 4; i++ )
1393
                        fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1394
            }
1395
        } else {
1396
            for( i = 0; i < 4; i++ ) {
1397
                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1398
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1399
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1400
            }
1401
        }
1402

    
1403
        for( list = 0; list < h->list_count; list++ ) {
1404
                for( i = 0; i < 4; i++ ) {
1405
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
1406
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
1407
                        if( h->ref_count[list] > 1 ){
1408
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1409
                            if(ref[list][i] >= (unsigned)h->ref_count[list]){
1410
                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1411
                                return -1;
1412
                            }
1413
                        }else
1414
                            ref[list][i] = 0;
1415
                    } else {
1416
                        ref[list][i] = -1;
1417
                    }
1418
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
1419
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1420
                }
1421
        }
1422

    
1423
        if(dct8x8_allowed)
1424
            dct8x8_allowed = get_dct8x8_allowed(h);
1425

    
1426
        for(list=0; list<h->list_count; list++){
1427
            for(i=0; i<4; i++){
1428
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1429
                if(IS_DIRECT(h->sub_mb_type[i])){
1430
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1431
                    continue;
1432
                }
1433

    
1434
                if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1435
                    const int sub_mb_type= h->sub_mb_type[i];
1436
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1437
                    for(j=0; j<sub_partition_count[i]; j++){
1438
                        int mpx, mpy;
1439
                        int mx, my;
1440
                        const int index= 4*i + block_width*j;
1441
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1442
                        int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1443
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1444

    
1445
                        mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1446
                        my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1447
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1448

    
1449
                        if(IS_SUB_8X8(sub_mb_type)){
1450
                            mv_cache[ 1 ][0]=
1451
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1452
                            mv_cache[ 1 ][1]=
1453
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1454

    
1455
                            mvd_cache[ 1 ][0]=
1456
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1457
                            mvd_cache[ 1 ][1]=
1458
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1459
                        }else if(IS_SUB_8X4(sub_mb_type)){
1460
                            mv_cache[ 1 ][0]= mx;
1461
                            mv_cache[ 1 ][1]= my;
1462

    
1463
                            mvd_cache[ 1 ][0]= mx - mpx;
1464
                            mvd_cache[ 1 ][1]= my - mpy;
1465
                        }else if(IS_SUB_4X8(sub_mb_type)){
1466
                            mv_cache[ 8 ][0]= mx;
1467
                            mv_cache[ 8 ][1]= my;
1468

    
1469
                            mvd_cache[ 8 ][0]= mx - mpx;
1470
                            mvd_cache[ 8 ][1]= my - mpy;
1471
                        }
1472
                        mv_cache[ 0 ][0]= mx;
1473
                        mv_cache[ 0 ][1]= my;
1474

    
1475
                        mvd_cache[ 0 ][0]= mx - mpx;
1476
                        mvd_cache[ 0 ][1]= my - mpy;
1477
                    }
1478
                }else{
1479
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1480
                    uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1481
                    p[0] = p[1] = p[8] = p[9] = 0;
1482
                    pd[0]= pd[1]= pd[8]= pd[9]= 0;
1483
                }
1484
            }
1485
        }
1486
    } else if( IS_DIRECT(mb_type) ) {
1487
        ff_h264_pred_direct_motion(h, &mb_type);
1488
        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1489
        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1490
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1491
    } else {
1492
        int list, mx, my, i, mpx, mpy;
1493
        if(IS_16X16(mb_type)){
1494
            for(list=0; list<h->list_count; list++){
1495
                if(IS_DIR(mb_type, 0, list)){
1496
                    int ref;
1497
                    if(h->ref_count[list] > 1){
1498
                        ref= decode_cabac_mb_ref(h, list, 0);
1499
                        if(ref >= (unsigned)h->ref_count[list]){
1500
                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1501
                            return -1;
1502
                        }
1503
                    }else
1504
                        ref=0;
1505
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1506
                }else
1507
                    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
1508
            }
1509
            for(list=0; list<h->list_count; list++){
1510
                if(IS_DIR(mb_type, 0, list)){
1511
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1512

    
1513
                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1514
                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1515
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1516

    
1517
                    fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1518
                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
1519
                }else
1520
                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
1521
            }
1522
        }
1523
        else if(IS_16X8(mb_type)){
1524
            for(list=0; list<h->list_count; list++){
1525
                    for(i=0; i<2; i++){
1526
                        if(IS_DIR(mb_type, i, list)){
1527
                            int ref;
1528
                            if(h->ref_count[list] > 1){
1529
                                ref= decode_cabac_mb_ref( h, list, 8*i );
1530
                                if(ref >= (unsigned)h->ref_count[list]){
1531
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1532
                                    return -1;
1533
                                }
1534
                            }else
1535
                                ref=0;
1536
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
1537
                        }else
1538
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
1539
                    }
1540
            }
1541
            for(list=0; list<h->list_count; list++){
1542
                for(i=0; i<2; i++){
1543
                    if(IS_DIR(mb_type, i, list)){
1544
                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
1545
                        mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
1546
                        my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
1547
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1548

    
1549
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1550
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1551
                    }else{
1552
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1553
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1554
                    }
1555
                }
1556
            }
1557
        }else{
1558
            assert(IS_8X16(mb_type));
1559
            for(list=0; list<h->list_count; list++){
1560
                    for(i=0; i<2; i++){
1561
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1562
                            int ref;
1563
                            if(h->ref_count[list] > 1){
1564
                                ref= decode_cabac_mb_ref( h, list, 4*i );
1565
                                if(ref >= (unsigned)h->ref_count[list]){
1566
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1567
                                    return -1;
1568
                                }
1569
                            }else
1570
                                ref=0;
1571
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1572
                        }else
1573
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1574
                    }
1575
            }
1576
            for(list=0; list<h->list_count; list++){
1577
                for(i=0; i<2; i++){
1578
                    if(IS_DIR(mb_type, i, list)){
1579
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1580
                        mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1581
                        my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1582

    
1583
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1584
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1585
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1586
                    }else{
1587
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1588
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1589
                    }
1590
                }
1591
            }
1592
        }
1593
    }
1594

    
1595
   if( IS_INTER( mb_type ) ) {
1596
        h->chroma_pred_mode_table[mb_xy] = 0;
1597
        write_back_motion( h, mb_type );
1598
   }
1599

    
1600
    if( !IS_INTRA16x16( mb_type ) ) {
1601
        cbp  = decode_cabac_mb_cbp_luma( h );
1602
        if(CHROMA)
1603
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1604
    }
1605

    
1606
    h->cbp_table[mb_xy] = h->cbp = cbp;
1607

    
1608
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1609
        mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1610
    }
1611
    s->current_picture.mb_type[mb_xy]= mb_type;
1612

    
1613
    if( cbp || IS_INTRA16x16( mb_type ) ) {
1614
        const uint8_t *scan, *scan8x8, *dc_scan;
1615
        const uint32_t *qmul;
1616

    
1617
        if(IS_INTERLACED(mb_type)){
1618
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1619
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
1620
            dc_scan= luma_dc_field_scan;
1621
        }else{
1622
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1623
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1624
            dc_scan= luma_dc_zigzag_scan;
1625
        }
1626

    
1627
        // decode_cabac_mb_dqp
1628
        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1629
            int val = 1;
1630
            int ctx= 2;
1631

    
1632
            while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1633
                ctx= 3;
1634
                val++;
1635
                if(val > 102){ //prevent infinite loop
1636
                    av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1637
                    return -1;
1638
                }
1639
            }
1640

    
1641
            if( val&0x01 )
1642
                val=   (val + 1)>>1 ;
1643
            else
1644
                val= -((val + 1)>>1);
1645
            h->last_qscale_diff = val;
1646
            s->qscale += val;
1647
            if(((unsigned)s->qscale) > 51){
1648
                if(s->qscale<0) s->qscale+= 52;
1649
                else            s->qscale-= 52;
1650
            }
1651
            h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1652
            h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1653
        }else
1654
            h->last_qscale_diff=0;
1655

    
1656
        if( IS_INTRA16x16( mb_type ) ) {
1657
            int i;
1658
            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1659
            decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1660

    
1661
            if( cbp&15 ) {
1662
                qmul = h->dequant4_coeff[0][s->qscale];
1663
                for( i = 0; i < 16; i++ ) {
1664
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1665
                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1666
                }
1667
            } else {
1668
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1669
            }
1670
        } else {
1671
            int i8x8, i4x4;
1672
            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1673
                if( cbp & (1<<i8x8) ) {
1674
                    if( IS_8x8DCT(mb_type) ) {
1675
                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1676
                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1677
                    } else {
1678
                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1679
                        for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1680
                            const int index = 4*i8x8 + i4x4;
1681
                            //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1682
//START_TIMER
1683
                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1684
//STOP_TIMER("decode_residual")
1685
                        }
1686
                    }
1687
                } else {
1688
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1689
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1690
                }
1691
            }
1692
        }
1693

    
1694
        if( cbp&0x30 ){
1695
            int c;
1696
            for( c = 0; c < 2; c++ ) {
1697
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1698
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1699
            }
1700
        }
1701

    
1702
        if( cbp&0x20 ) {
1703
            int c, i;
1704
            for( c = 0; c < 2; c++ ) {
1705
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1706
                for( i = 0; i < 4; i++ ) {
1707
                    const int index = 16 + 4 * c + i;
1708
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1709
                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1710
                }
1711
            }
1712
        } else {
1713
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1714
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1715
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1716
        }
1717
    } else {
1718
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1719
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1720
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1721
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1722
        h->last_qscale_diff = 0;
1723
    }
1724

    
1725
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1726
    write_back_non_zero_count(h);
1727

    
1728
    if(MB_MBAFF){
1729
        h->ref_count[0] >>= 1;
1730
        h->ref_count[1] >>= 1;
1731
    }
1732

    
1733
    return 0;
1734
}