Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ f4ce8531

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
            mvd += get_cabac_bypass( &h->cabac )<<k;
941
        }
942
    }
943
    return get_cabac_bypass_sign( &h->cabac, -mvd );
944
}
945

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

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

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

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

    
970
    return ctx + 4 * cat;
971
}
972

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

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

    
1015
    int index[64];
1016

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

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

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

    
1038

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1159
}
1160

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

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

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

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

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

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

    
1209
            decode_mb_skip(h);
1210

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

    
1215
            return 0;
1216

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

    
1225
    h->prev_mb_skipped = 0;
1226

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

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

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

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

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

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

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

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

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

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

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

    
1333
    fill_decode_caches(h, mb_type);
1334

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

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

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

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

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

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

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

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

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

    
1440
                        mpx= abs(mpx-mx);
1441
                        mpy= abs(mpy-my);
1442
                        if(IS_SUB_8X8(sub_mb_type)){
1443
                            mv_cache[ 1 ][0]=
1444
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1445
                            mv_cache[ 1 ][1]=
1446
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1447

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1726
    return 0;
1727
}