Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ 69cc3183

History | View | Annotate | Download (71.2 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
    const int8_t (*tab)[2];
692

    
693
    if( h->slice_type_nos == FF_I_TYPE ) tab = cabac_context_init_I;
694
    else                                 tab = cabac_context_init_PB[h->cabac_init_idc];
695

    
696
    /* calculate pre-state */
697
    for( i= 0; i < 460; i++ ) {
698
        int pre = 2*(((tab[i][0] * s->qscale) >>4 ) + tab[i][1]) - 127;
699

    
700
        pre^= pre>>31;
701
        if(pre > 124)
702
            pre= 124 + (pre&1);
703

    
704
        h->cabac_state[i] =  pre;
705
    }
706
}
707

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

    
713
    unsigned long ctx = 0;
714

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

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

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

    
725
    if(intra_slice){
726
        int ctx=0;
727
        if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
728
            ctx++;
729
        if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
730
            ctx++;
731
        if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
732
            return 0;   /* I4x4 */
733
        state += 2;
734
    }else{
735
        if( get_cabac_noinline( &h->cabac, state ) == 0 )
736
            return 0;   /* I4x4 */
737
    }
738

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

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

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

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

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

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

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

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

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

    
797
    return mode + ( mode >= pred_mode );
798
}
799

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

    
804
    int ctx = 0;
805

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

    
810
    if( h->top_type     && h->chroma_pred_mode_table[mbb_xy] != 0 )
811
        ctx++;
812

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

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

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

    
827
    cbp_a = h->left_cbp;
828
    cbp_b = h->top_cbp;
829

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
967
    if( nza > 0 )
968
        ctx++;
969

    
970
    if( nzb > 0 )
971
        ctx += 2;
972

    
973
    return ctx + 4 * cat;
974
}
975

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

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

    
1018
    int index[64];
1019

    
1020
    int av_unused last;
1021
    int coeff_count = 0;
1022
    int node_ctx = 0;
1023

    
1024
    uint8_t *significant_coeff_ctx_base;
1025
    uint8_t *last_coeff_ctx_base;
1026
    uint8_t *abs_level_m1_ctx_base;
1027

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

    
1041

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

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

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

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

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

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

    
1115
    do {
1116
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1117

    
1118
        int j= scantable[index[--coeff_count]];
1119

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

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

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

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

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

    
1162
}
1163

    
1164
#if !CONFIG_SMALL
1165
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 ) {
1166
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1167
}
1168

    
1169
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 ) {
1170
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1171
}
1172
#endif
1173

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

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

    
1193
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1194

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

    
1212
            decode_mb_skip(h);
1213

    
1214
            h->cbp_table[mb_xy] = 0;
1215
            h->chroma_pred_mode_table[mb_xy] = 0;
1216
            h->last_qscale_diff = 0;
1217

    
1218
            return 0;
1219

    
1220
        }
1221
    }
1222
    if(FRAME_MBAFF){
1223
        if( (s->mb_y&1) == 0 )
1224
            h->mb_mbaff =
1225
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1226
    }
1227

    
1228
    h->prev_mb_skipped = 0;
1229

    
1230
    fill_decode_neighbors(h, -(MB_FIELD));
1231

    
1232
    if( h->slice_type_nos == FF_B_TYPE ) {
1233
        int ctx = 0;
1234
        assert(h->slice_type_nos == FF_B_TYPE);
1235

    
1236
        if( !IS_DIRECT( h->left_type[0]-1 ) )
1237
            ctx++;
1238
        if( !IS_DIRECT( h->top_type-1 ) )
1239
            ctx++;
1240

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

    
1297
    h->slice_table[ mb_xy ]= h->slice_num;
1298

    
1299
    if(IS_INTRA_PCM(mb_type)) {
1300
        const uint8_t *ptr;
1301

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

    
1311
        // The pixels are stored in the same order as levels in h->mb array.
1312
        memcpy(h->mb, ptr, 256); ptr+=256;
1313
        if(CHROMA){
1314
            memcpy(h->mb+128, ptr, 128); ptr+=128;
1315
        }
1316

    
1317
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1318

    
1319
        // All blocks are present
1320
        h->cbp_table[mb_xy] = 0x1ef;
1321
        h->chroma_pred_mode_table[mb_xy] = 0;
1322
        // In deblocking, the quantizer is 0
1323
        s->current_picture.qscale_table[mb_xy]= 0;
1324
        // All coeffs are present
1325
        memset(h->non_zero_count[mb_xy], 16, 32);
1326
        s->current_picture.mb_type[mb_xy]= mb_type;
1327
        h->last_qscale_diff = 0;
1328
        return 0;
1329
    }
1330

    
1331
    if(MB_MBAFF){
1332
        h->ref_count[0] <<= 1;
1333
        h->ref_count[1] <<= 1;
1334
    }
1335

    
1336
    fill_decode_caches(h, mb_type);
1337

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

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

    
1366
            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1367
            if( pred_mode < 0 ) return -1;
1368
            h->chroma_pred_mode= pred_mode;
1369
        }
1370
    } else if( partition_count == 4 ) {
1371
        int i, j, sub_partition_count[4], list, ref[2][4];
1372

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

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

    
1417
        if(dct8x8_allowed)
1418
            dct8x8_allowed = get_dct8x8_allowed(h);
1419

    
1420
        for(list=0; list<h->list_count; list++){
1421
            for(i=0; i<4; i++){
1422
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1423
                if(IS_DIRECT(h->sub_mb_type[i])){
1424
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1425
                    continue;
1426
                }
1427

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

    
1439
                        mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1440
                        my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1441
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1442

    
1443
                        if(IS_SUB_8X8(sub_mb_type)){
1444
                            mv_cache[ 1 ][0]=
1445
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1446
                            mv_cache[ 1 ][1]=
1447
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1448

    
1449
                            mvd_cache[ 1 ][0]=
1450
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1451
                            mvd_cache[ 1 ][1]=
1452
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1453
                        }else if(IS_SUB_8X4(sub_mb_type)){
1454
                            mv_cache[ 1 ][0]= mx;
1455
                            mv_cache[ 1 ][1]= my;
1456

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

    
1463
                            mvd_cache[ 8 ][0]= mx - mpx;
1464
                            mvd_cache[ 8 ][1]= my - mpy;
1465
                        }
1466
                        mv_cache[ 0 ][0]= mx;
1467
                        mv_cache[ 0 ][1]= my;
1468

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

    
1507
                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1508
                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1509
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1510

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

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

    
1577
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1578
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1579
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1580
                    }else{
1581
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1582
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1583
                    }
1584
                }
1585
            }
1586
        }
1587
    }
1588

    
1589
   if( IS_INTER( mb_type ) ) {
1590
        h->chroma_pred_mode_table[mb_xy] = 0;
1591
        write_back_motion( h, mb_type );
1592
   }
1593

    
1594
    if( !IS_INTRA16x16( mb_type ) ) {
1595
        cbp  = decode_cabac_mb_cbp_luma( h );
1596
        if(CHROMA)
1597
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1598
    }
1599

    
1600
    h->cbp_table[mb_xy] = h->cbp = cbp;
1601

    
1602
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1603
        mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1604
    }
1605
    s->current_picture.mb_type[mb_xy]= mb_type;
1606

    
1607
    if( cbp || IS_INTRA16x16( mb_type ) ) {
1608
        const uint8_t *scan, *scan8x8, *dc_scan;
1609
        const uint32_t *qmul;
1610

    
1611
        if(IS_INTERLACED(mb_type)){
1612
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1613
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
1614
            dc_scan= luma_dc_field_scan;
1615
        }else{
1616
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1617
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1618
            dc_scan= luma_dc_zigzag_scan;
1619
        }
1620

    
1621
        // decode_cabac_mb_dqp
1622
        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1623
            int val = 1;
1624
            int ctx= 2;
1625

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

    
1635
            if( val&0x01 )
1636
                val=   (val + 1)>>1 ;
1637
            else
1638
                val= -((val + 1)>>1);
1639
            h->last_qscale_diff = val;
1640
            s->qscale += val;
1641
            if(((unsigned)s->qscale) > 51){
1642
                if(s->qscale<0) s->qscale+= 52;
1643
                else            s->qscale-= 52;
1644
            }
1645
            h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1646
            h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1647
        }else
1648
            h->last_qscale_diff=0;
1649

    
1650
        if( IS_INTRA16x16( mb_type ) ) {
1651
            int i;
1652
            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1653
            decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1654

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

    
1688
        if( cbp&0x30 ){
1689
            int c;
1690
            for( c = 0; c < 2; c++ ) {
1691
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1692
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1693
            }
1694
        }
1695

    
1696
        if( cbp&0x20 ) {
1697
            int c, i;
1698
            for( c = 0; c < 2; c++ ) {
1699
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1700
                for( i = 0; i < 4; i++ ) {
1701
                    const int index = 16 + 4 * c + i;
1702
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1703
                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1704
                }
1705
            }
1706
        } else {
1707
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1708
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1709
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1710
        }
1711
    } else {
1712
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1713
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
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
        h->last_qscale_diff = 0;
1717
    }
1718

    
1719
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1720
    write_back_non_zero_count(h);
1721

    
1722
    if(MB_MBAFF){
1723
        h->ref_count[0] >>= 1;
1724
        h->ref_count[1] >>= 1;
1725
    }
1726

    
1727
    return 0;
1728
}