Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ dc172ecc

History | View | Annotate | Download (71.8 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

    
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 ctxbase, int amvd, int *mvda) {
913
    int mvd;
914

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

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

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

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

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

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

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

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

    
984
    return ctx + 4 * cat;
985
}
986

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

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

    
1029
    int index[64];
1030

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

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

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

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

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

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

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

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

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

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

    
1157
}
1158

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

    
1163
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 ) {
1164
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1165
}
1166

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

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

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

    
1188
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 ) {
1189
    /* read coded block flag */
1190
    if( cat != 5 && get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, 0 ) ] ) == 0 ) {
1191
        h->non_zero_count_cache[scan8[n]] = 0;
1192
        return;
1193
    }
1194
    decode_cabac_residual_nondc_internal( h, block, cat, n, scantable, qmul, max_coeff );
1195
}
1196

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

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

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

    
1226
            decode_mb_skip(h);
1227

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

    
1232
            return 0;
1233

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

    
1242
    h->prev_mb_skipped = 0;
1243

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

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

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

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

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

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

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

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

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

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

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

    
1351
    fill_decode_caches(h, mb_type);
1352

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1629
        // decode_cabac_mb_dqp
1630
        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1631
            int val = 1;
1632
            int ctx= 2;
1633

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

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

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

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

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

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

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

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

    
1739
    return 0;
1740
}