Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ e69bfde6

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 mbb_xy = h->mb_xy - 2L*s->mb_stride;
711

    
712
    unsigned long ctx = 0;
713

    
714
    ctx += h->mb_field_decoding_flag & !!s->mb_x; //for FMO:(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
        int ctx=0;
726
        if( h->left_type[0] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
727
            ctx++;
728
        if( h->top_type     & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
729
            ctx++;
730
        if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
731
            return 0;   /* I4x4 */
732
        state += 2;
733
    }else{
734
        if( get_cabac_noinline( &h->cabac, state ) == 0 )
735
            return 0;   /* I4x4 */
736
    }
737

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

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

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

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

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

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

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

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

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

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

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

    
803
    int ctx = 0;
804

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
918
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2) + (amvd>32)]))
919
        return 0;
920

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

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

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

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

    
965
    if( nza > 0 )
966
        ctx++;
967

    
968
    if( nzb > 0 )
969
        ctx += 2;
970

    
971
    return ctx + 4 * cat;
972
}
973

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

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

    
1016
    int index[64];
1017

    
1018
    int av_unused last;
1019
    int coeff_count = 0;
1020
    int node_ctx = 0;
1021

    
1022
    uint8_t *significant_coeff_ctx_base;
1023
    uint8_t *last_coeff_ctx_base;
1024
    uint8_t *abs_level_m1_ctx_base;
1025

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

    
1039

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

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

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

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

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

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

    
1113
    do {
1114
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1115

    
1116
        int j= scantable[index[--coeff_count]];
1117

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

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

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

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

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

    
1160
}
1161

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

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

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

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

    
1191
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1192

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

    
1210
            decode_mb_skip(h);
1211

    
1212
            h->cbp_table[mb_xy] = 0;
1213
            h->chroma_pred_mode_table[mb_xy] = 0;
1214
            h->last_qscale_diff = 0;
1215

    
1216
            return 0;
1217

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

    
1226
    h->prev_mb_skipped = 0;
1227

    
1228
    fill_decode_neighbors(h, -(MB_FIELD));
1229

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

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

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

    
1295
    h->slice_table[ mb_xy ]= h->slice_num;
1296

    
1297
    if(IS_INTRA_PCM(mb_type)) {
1298
        const uint8_t *ptr;
1299

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

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

    
1315
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1316

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

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

    
1334
    fill_decode_caches(h, mb_type);
1335

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

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

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

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

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

    
1415
        if(dct8x8_allowed)
1416
            dct8x8_allowed = get_dct8x8_allowed(h);
1417

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

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

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

    
1441
                        mpx= abs(mpx-mx);
1442
                        mpy= abs(mpy-my);
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]= mpx;
1451
                            mvd_cache[ 1 ][1]=
1452
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= 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]=  mpx;
1458
                            mvd_cache[ 1 ][1]= 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]= mpx;
1464
                            mvd_cache[ 8 ][1]= mpy;
1465
                        }
1466
                        mv_cache[ 0 ][0]= mx;
1467
                        mv_cache[ 0 ][1]= my;
1468

    
1469
                        mvd_cache[ 0 ][0]= mpx;
1470
                        mvd_cache[ 0 ][1]= 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(abs(mx-mpx),abs(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(abs(mx-mpx),abs(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(abs(mx-mpx),abs(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
}