Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ a305449d

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
    int ctx = (amvd>2) + (amvd>32);
918

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

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

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

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

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

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

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

    
972
    return ctx + 4 * cat;
973
}
974

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

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

    
1017
    int index[64];
1018

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

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

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

    
1040

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1161
}
1162

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

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

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

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

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

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

    
1211
            decode_mb_skip(h);
1212

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

    
1217
            return 0;
1218

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

    
1227
    h->prev_mb_skipped = 0;
1228

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

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

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

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

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

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

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

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

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

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

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

    
1335
    fill_decode_caches(h, mb_type);
1336

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1728
    return 0;
1729
}