Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ d268bed2

History | View | Annotate | Download (72 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
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
    const int slice_qp = av_clip(s->qscale - 6*(h->sps.bit_depth_luma-8), 0, 51);
693

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

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

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

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

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

    
713
    unsigned long ctx = 0;
714

    
715
    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);
716
    ctx += (s->current_picture.mb_type[mbb_xy]>>7)&(h->slice_table[mbb_xy] == h->slice_num);
717

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
804
    int ctx = 0;
805

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
913
static int decode_cabac_mb_mvd( H264Context *h, int ctxbase, int amvd, int *mvda) {
914
    int mvd;
915

    
916
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
917
//    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
918
        *mvda= 0;
919
        return 0;
920
    }
921

    
922
    mvd= 1;
923
    ctxbase+= 3;
924
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase] ) ) {
925
        if( mvd < 4 )
926
            ctxbase++;
927
        mvd++;
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
            mvd += get_cabac_bypass( &h->cabac )<<k;
942
        }
943
        *mvda=mvd < 70 ? mvd : 70;
944
    }else
945
        *mvda=mvd;
946
    return get_cabac_bypass_sign( &h->cabac, -mvd );
947
}
948

    
949
#define DECODE_CABAC_MB_MVD( h,  list,  n )\
950
{\
951
    int amvd0 = h->mvd_cache[list][scan8[n] - 1][0] +\
952
                h->mvd_cache[list][scan8[n] - 8][0];\
953
    int amvd1 = h->mvd_cache[list][scan8[n] - 1][1] +\
954
                h->mvd_cache[list][scan8[n] - 8][1];\
955
\
956
    mx += decode_cabac_mb_mvd( h, 40, amvd0, &mpx );\
957
    my += decode_cabac_mb_mvd( h, 47, amvd1, &mpy );\
958
}
959

    
960
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
961
    int nza, nzb;
962
    int ctx = 0;
963

    
964
    if( is_dc ) {
965
        if( cat == 0 ) {
966
            nza = h->left_cbp&0x100;
967
            nzb = h-> top_cbp&0x100;
968
        } else {
969
            idx -= CHROMA_DC_BLOCK_INDEX;
970
            nza = (h->left_cbp>>(6+idx))&0x01;
971
            nzb = (h-> top_cbp>>(6+idx))&0x01;
972
        }
973
    } else {
974
        assert(cat == 1 || cat == 2 || cat == 4);
975
        nza = h->non_zero_count_cache[scan8[idx] - 1];
976
        nzb = h->non_zero_count_cache[scan8[idx] - 8];
977
    }
978

    
979
    if( nza > 0 )
980
        ctx++;
981

    
982
    if( nzb > 0 )
983
        ctx += 2;
984

    
985
    return ctx + 4 * cat;
986
}
987

    
988
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
989
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
990
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
991
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
992
    5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
993
};
994

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

    
1030
    int index[64];
1031

    
1032
    int av_unused last;
1033
    int coeff_count = 0;
1034
    int node_ctx = 0;
1035

    
1036
    uint8_t *significant_coeff_ctx_base;
1037
    uint8_t *last_coeff_ctx_base;
1038
    uint8_t *abs_level_m1_ctx_base;
1039

    
1040
#if !ARCH_X86
1041
#define CABAC_ON_STACK
1042
#endif
1043
#ifdef CABAC_ON_STACK
1044
#define CC &cc
1045
    CABACContext cc;
1046
    cc.range     = h->cabac.range;
1047
    cc.low       = h->cabac.low;
1048
    cc.bytestream= h->cabac.bytestream;
1049
#else
1050
#define CC &h->cabac
1051
#endif
1052

    
1053
    significant_coeff_ctx_base = h->cabac_state
1054
        + significant_coeff_flag_offset[MB_FIELD][cat];
1055
    last_coeff_ctx_base = h->cabac_state
1056
        + last_coeff_flag_offset[MB_FIELD][cat];
1057
    abs_level_m1_ctx_base = h->cabac_state
1058
        + coeff_abs_level_m1_offset[cat];
1059

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

    
1089
    if( is_dc ) {
1090
        if( cat == 0 )
1091
            h->cbp_table[h->mb_xy] |= 0x100;
1092
        else
1093
            h->cbp_table[h->mb_xy] |= 0x40 << (n - CHROMA_DC_BLOCK_INDEX);
1094
        h->non_zero_count_cache[scan8[n]] = coeff_count;
1095
    } else {
1096
        if( cat == 5 )
1097
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1098
        else {
1099
            assert( cat == 1 || cat == 2 || cat == 4 );
1100
            h->non_zero_count_cache[scan8[n]] = coeff_count;
1101
        }
1102
    }
1103

    
1104
    do {
1105
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1106

    
1107
        int j= scantable[index[--coeff_count]];
1108

    
1109
#define STORE_BLOCK(type) \
1110
        if( get_cabac( CC, ctx ) == 0 ) { \
1111
            node_ctx = coeff_abs_level_transition[0][node_ctx]; \
1112
            if( is_dc ) { \
1113
                ((type*)block)[j] = get_cabac_bypass_sign( CC, -1); \
1114
            }else{ \
1115
                ((type*)block)[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6; \
1116
            } \
1117
        } else { \
1118
            int coeff_abs = 2; \
1119
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \
1120
            node_ctx = coeff_abs_level_transition[1][node_ctx]; \
1121
\
1122
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
1123
                coeff_abs++; \
1124
            } \
1125
\
1126
            if( coeff_abs >= 15 ) { \
1127
                int j = 0; \
1128
                while( get_cabac_bypass( CC ) ) { \
1129
                    j++; \
1130
                } \
1131
\
1132
                coeff_abs=1; \
1133
                while( j-- ) { \
1134
                    coeff_abs += coeff_abs + get_cabac_bypass( CC ); \
1135
                } \
1136
                coeff_abs+= 14; \
1137
            } \
1138
\
1139
            if( is_dc ) { \
1140
                ((type*)block)[j] = get_cabac_bypass_sign( CC, -coeff_abs ); \
1141
            }else{ \
1142
                ((type*)block)[j] = ((int)(get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32)) >> 6; \
1143
            } \
1144
        }
1145

    
1146
        if (h->pixel_size == 2) {
1147
            STORE_BLOCK(int32_t)
1148
        } else {
1149
            STORE_BLOCK(int16_t)
1150
        }
1151
    } while( coeff_count );
1152
#ifdef CABAC_ON_STACK
1153
            h->cabac.range     = cc.range     ;
1154
            h->cabac.low       = cc.low       ;
1155
            h->cabac.bytestream= cc.bytestream;
1156
#endif
1157

    
1158
}
1159

    
1160
static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1161
    decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
1162
}
1163

    
1164
static void decode_cabac_residual_nondc_internal( 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, 0);
1166
}
1167

    
1168
/* cat: 0-> DC 16x16  n = 0
1169
 *      1-> AC 16x16  n = luma4x4idx
1170
 *      2-> Luma4x4   n = luma4x4idx
1171
 *      3-> DC Chroma n = iCbCr
1172
 *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1173
 *      5-> Luma8x8   n = 4 * luma8x8idx */
1174

    
1175
/* Partially inline the CABAC residual decode: inline the coded block flag.
1176
 * This has very little impact on binary size and improves performance
1177
 * because it allows improved constant propagation into get_cabac_cbf_ctx,
1178
 * as well as because most blocks have zero CBFs. */
1179

    
1180
static av_always_inline void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
1181
    /* read coded block flag */
1182
    if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 1 ) ] ) == 0 ) {
1183
        h->non_zero_count_cache[scan8[n]] = 0;
1184
        return;
1185
    }
1186
    decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
1187
}
1188

    
1189
static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1190
    /* read coded block flag */
1191
    if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1192
        h->non_zero_count_cache[scan8[n]] = 0;
1193
        return;
1194
    }
1195
    decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1196
}
1197

    
1198
/**
1199
 * decodes a macroblock
1200
 * @return 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1201
 */
1202
int ff_h264_decode_mb_cabac(H264Context *h) {
1203
    MpegEncContext * const s = &h->s;
1204
    int mb_xy;
1205
    int mb_type, partition_count, cbp = 0;
1206
    int dct8x8_allowed= h->pps.transform_8x8_mode;
1207

    
1208
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1209

    
1210
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1211
    if( h->slice_type_nos != FF_I_TYPE ) {
1212
        int skip;
1213
        /* a skipped mb needs the aff flag from the following mb */
1214
        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1215
            skip = h->next_mb_skipped;
1216
        else
1217
            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1218
        /* read skip flags */
1219
        if( skip ) {
1220
            if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1221
                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1222
                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1223
                if(!h->next_mb_skipped)
1224
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1225
            }
1226

    
1227
            decode_mb_skip(h);
1228

    
1229
            h->cbp_table[mb_xy] = 0;
1230
            h->chroma_pred_mode_table[mb_xy] = 0;
1231
            h->last_qscale_diff = 0;
1232

    
1233
            return 0;
1234

    
1235
        }
1236
    }
1237
    if(FRAME_MBAFF){
1238
        if( (s->mb_y&1) == 0 )
1239
            h->mb_mbaff =
1240
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1241
    }
1242

    
1243
    h->prev_mb_skipped = 0;
1244

    
1245
    fill_decode_neighbors(h, -(MB_FIELD));
1246

    
1247
    if( h->slice_type_nos == FF_B_TYPE ) {
1248
        int ctx = 0;
1249
        assert(h->slice_type_nos == FF_B_TYPE);
1250

    
1251
        if( !IS_DIRECT( h->left_type[0]-1 ) )
1252
            ctx++;
1253
        if( !IS_DIRECT( h->top_type-1 ) )
1254
            ctx++;
1255

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

    
1312
    h->slice_table[ mb_xy ]= h->slice_num;
1313

    
1314
    if(IS_INTRA_PCM(mb_type)) {
1315
        const int mb_size = 384*h->sps.bit_depth_luma/8;
1316
        const uint8_t *ptr;
1317

    
1318
        // We assume these blocks are very rare so we do not optimize it.
1319
        // FIXME The two following lines get the bitstream position in the cabac
1320
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
1321
        ptr= h->cabac.bytestream;
1322
        if(h->cabac.low&0x1) ptr--;
1323
        if(CABAC_BITS==16){
1324
            if(h->cabac.low&0x1FF) ptr--;
1325
        }
1326

    
1327
        // The pixels are stored in the same order as levels in h->mb array.
1328
        memcpy(h->mb, ptr, 2*mb_size/3); ptr+=2*mb_size/3;
1329
        if(CHROMA){
1330
            memcpy(h->mb+mb_size/3, ptr, mb_size/3); ptr+=mb_size/3;
1331
        }
1332

    
1333
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1334

    
1335
        // All blocks are present
1336
        h->cbp_table[mb_xy] = 0x1ef;
1337
        h->chroma_pred_mode_table[mb_xy] = 0;
1338
        // In deblocking, the quantizer is 0
1339
        s->current_picture.qscale_table[mb_xy]= 0;
1340
        // All coeffs are present
1341
        memset(h->non_zero_count[mb_xy], 16, 32);
1342
        s->current_picture.mb_type[mb_xy]= mb_type;
1343
        h->last_qscale_diff = 0;
1344
        return 0;
1345
    }
1346

    
1347
    if(MB_MBAFF){
1348
        h->ref_count[0] <<= 1;
1349
        h->ref_count[1] <<= 1;
1350
    }
1351

    
1352
    fill_decode_caches(h, mb_type);
1353

    
1354
    if( IS_INTRA( mb_type ) ) {
1355
        int i, pred_mode;
1356
        if( IS_INTRA4x4( mb_type ) ) {
1357
            if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1358
                mb_type |= MB_TYPE_8x8DCT;
1359
                for( i = 0; i < 16; i+=4 ) {
1360
                    int pred = pred_intra_mode( h, i );
1361
                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1362
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1363
                }
1364
            } else {
1365
                for( i = 0; i < 16; i++ ) {
1366
                    int pred = pred_intra_mode( h, i );
1367
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1368

    
1369
                //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1370
                }
1371
            }
1372
            ff_h264_write_back_intra_pred_mode(h);
1373
            if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1374
        } else {
1375
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1376
            if( h->intra16x16_pred_mode < 0 ) return -1;
1377
        }
1378
        if(CHROMA){
1379
            h->chroma_pred_mode_table[mb_xy] =
1380
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1381

    
1382
            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1383
            if( pred_mode < 0 ) return -1;
1384
            h->chroma_pred_mode= pred_mode;
1385
        } else {
1386
            h->chroma_pred_mode= DC_128_PRED8x8;
1387
        }
1388
    } else if( partition_count == 4 ) {
1389
        int i, j, sub_partition_count[4], list, ref[2][4];
1390

    
1391
        if( h->slice_type_nos == FF_B_TYPE ) {
1392
            for( i = 0; i < 4; i++ ) {
1393
                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1394
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1395
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1396
            }
1397
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1398
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1399
                ff_h264_pred_direct_motion(h, &mb_type);
1400
                h->ref_cache[0][scan8[4]] =
1401
                h->ref_cache[1][scan8[4]] =
1402
                h->ref_cache[0][scan8[12]] =
1403
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1404
                    for( i = 0; i < 4; i++ )
1405
                        fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1406
            }
1407
        } else {
1408
            for( i = 0; i < 4; i++ ) {
1409
                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1410
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1411
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1412
            }
1413
        }
1414

    
1415
        for( list = 0; list < h->list_count; list++ ) {
1416
                for( i = 0; i < 4; i++ ) {
1417
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
1418
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
1419
                        if( h->ref_count[list] > 1 ){
1420
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1421
                            if(ref[list][i] >= (unsigned)h->ref_count[list]){
1422
                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1423
                                return -1;
1424
                            }
1425
                        }else
1426
                            ref[list][i] = 0;
1427
                    } else {
1428
                        ref[list][i] = -1;
1429
                    }
1430
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
1431
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1432
                }
1433
        }
1434

    
1435
        if(dct8x8_allowed)
1436
            dct8x8_allowed = get_dct8x8_allowed(h);
1437

    
1438
        for(list=0; list<h->list_count; list++){
1439
            for(i=0; i<4; i++){
1440
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1441
                if(IS_DIRECT(h->sub_mb_type[i])){
1442
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 2);
1443
                    continue;
1444
                }
1445

    
1446
                if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1447
                    const int sub_mb_type= h->sub_mb_type[i];
1448
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1449
                    for(j=0; j<sub_partition_count[i]; j++){
1450
                        int mpx, mpy;
1451
                        int mx, my;
1452
                        const int index= 4*i + block_width*j;
1453
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1454
                        uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1455
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
1456
                        DECODE_CABAC_MB_MVD( h, list, index)
1457
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1458

    
1459
                        if(IS_SUB_8X8(sub_mb_type)){
1460
                            mv_cache[ 1 ][0]=
1461
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1462
                            mv_cache[ 1 ][1]=
1463
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1464

    
1465
                            mvd_cache[ 1 ][0]=
1466
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mpx;
1467
                            mvd_cache[ 1 ][1]=
1468
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= mpy;
1469
                        }else if(IS_SUB_8X4(sub_mb_type)){
1470
                            mv_cache[ 1 ][0]= mx;
1471
                            mv_cache[ 1 ][1]= my;
1472

    
1473
                            mvd_cache[ 1 ][0]=  mpx;
1474
                            mvd_cache[ 1 ][1]= mpy;
1475
                        }else if(IS_SUB_4X8(sub_mb_type)){
1476
                            mv_cache[ 8 ][0]= mx;
1477
                            mv_cache[ 8 ][1]= my;
1478

    
1479
                            mvd_cache[ 8 ][0]= mpx;
1480
                            mvd_cache[ 8 ][1]= mpy;
1481
                        }
1482
                        mv_cache[ 0 ][0]= mx;
1483
                        mv_cache[ 0 ][1]= my;
1484

    
1485
                        mvd_cache[ 0 ][0]= mpx;
1486
                        mvd_cache[ 0 ][1]= mpy;
1487
                    }
1488
                }else{
1489
                    fill_rectangle(h->mv_cache [list][ scan8[4*i] ], 2, 2, 8, 0, 4);
1490
                    fill_rectangle(h->mvd_cache[list][ scan8[4*i] ], 2, 2, 8, 0, 2);
1491
                }
1492
            }
1493
        }
1494
    } else if( IS_DIRECT(mb_type) ) {
1495
        ff_h264_pred_direct_motion(h, &mb_type);
1496
        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
1497
        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
1498
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1499
    } else {
1500
        int list, i;
1501
        if(IS_16X16(mb_type)){
1502
            for(list=0; list<h->list_count; list++){
1503
                if(IS_DIR(mb_type, 0, list)){
1504
                    int ref;
1505
                    if(h->ref_count[list] > 1){
1506
                        ref= decode_cabac_mb_ref(h, list, 0);
1507
                        if(ref >= (unsigned)h->ref_count[list]){
1508
                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1509
                            return -1;
1510
                        }
1511
                    }else
1512
                        ref=0;
1513
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1514
                }
1515
            }
1516
            for(list=0; list<h->list_count; list++){
1517
                if(IS_DIR(mb_type, 0, list)){
1518
                    int mx,my,mpx,mpy;
1519
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
1520
                    DECODE_CABAC_MB_MVD( h, list, 0)
1521
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1522

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

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

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

    
1600
   if( IS_INTER( mb_type ) ) {
1601
        h->chroma_pred_mode_table[mb_xy] = 0;
1602
        write_back_motion( h, mb_type );
1603
   }
1604

    
1605
    if( !IS_INTRA16x16( mb_type ) ) {
1606
        cbp  = decode_cabac_mb_cbp_luma( h );
1607
        if(CHROMA)
1608
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1609
    }
1610

    
1611
    h->cbp_table[mb_xy] = h->cbp = cbp;
1612

    
1613
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1614
        mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1615
    }
1616
    s->current_picture.mb_type[mb_xy]= mb_type;
1617

    
1618
    if( cbp || IS_INTRA16x16( mb_type ) ) {
1619
        const uint8_t *scan, *scan8x8;
1620
        const uint32_t *qmul;
1621

    
1622
        if(IS_INTERLACED(mb_type)){
1623
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1624
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
1625
        }else{
1626
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1627
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1628
        }
1629

    
1630
        // decode_cabac_mb_dqp
1631
        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1632
            int val = 1;
1633
            int ctx= 2;
1634
            const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1635

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

    
1645
            if( val&0x01 )
1646
                val=   (val + 1)>>1 ;
1647
            else
1648
                val= -((val + 1)>>1);
1649
            h->last_qscale_diff = val;
1650
            s->qscale += val;
1651
            if(((unsigned)s->qscale) > max_qp){
1652
                if(s->qscale<0) s->qscale+= max_qp+1;
1653
                else            s->qscale-= max_qp+1;
1654
            }
1655
            h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1656
            h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1657
        }else
1658
            h->last_qscale_diff=0;
1659

    
1660
        if( IS_INTRA16x16( mb_type ) ) {
1661
            int i;
1662
            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1663
            AV_ZERO128(h->mb_luma_dc+0);
1664
            AV_ZERO128(h->mb_luma_dc+8);
1665
            AV_ZERO128(h->mb_luma_dc+16);
1666
            AV_ZERO128(h->mb_luma_dc+24);
1667
            decode_cabac_residual_dc( h, h->mb_luma_dc, 0, LUMA_DC_BLOCK_INDEX, scan, 16);
1668

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

    
1702
        if( cbp&0x30 ){
1703
            int c;
1704
            for( c = 0; c < 2; c++ ) {
1705
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1706
                decode_cabac_residual_dc(h, h->mb + (256 + 16*4*c)*h->pixel_size, 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
1707
            }
1708
        }
1709

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

    
1733
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1734
    write_back_non_zero_count(h);
1735

    
1736
    if(MB_MBAFF){
1737
        h->ref_count[0] >>= 1;
1738
        h->ref_count[1] >>= 1;
1739
    }
1740

    
1741
    return 0;
1742
}