Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ f4060611

History | View | Annotate | Download (72.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 libavcodec/h264_cabac.c
24
 * H.264 / AVC / MPEG4 part10 cabac decoding.
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 */
27

    
28
#define CABAC 1
29

    
30
#include "internal.h"
31
#include "dsputil.h"
32
#include "avcodec.h"
33
#include "h264.h"
34
#include "h264data.h"
35
#include "h264_mvpred.h"
36
#include "golomb.h"
37

    
38
#include "cabac.h"
39
#if ARCH_X86
40
#include "x86/h264_i386.h"
41
#endif
42

    
43
//#undef NDEBUG
44
#include <assert.h>
45

    
46
/* Cabac pre state table */
47

    
48
static const int8_t cabac_context_init_I[460][2] =
49
{
50
    /* 0 - 10 */
51
    { 20, -15 }, {  2, 54 },  {  3,  74 }, { 20, -15 },
52
    {  2,  54 }, {  3, 74 },  { -28,127 }, { -23, 104 },
53
    { -6,  53 }, { -1, 54 },  {  7,  51 },
54

    
55
    /* 11 - 23 unsused for I */
56
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
57
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
58
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
59
    { 0, 0 },
60

    
61
    /* 24- 39 */
62
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
63
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
64
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
65
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
66

    
67
    /* 40 - 53 */
68
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
69
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
70
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
71
    { 0, 0 },    { 0, 0 },
72

    
73
    /* 54 - 59 */
74
    { 0, 0 },    { 0, 0 },    { 0, 0 },      { 0, 0 },
75
    { 0, 0 },    { 0, 0 },
76

    
77
    /* 60 - 69 */
78
    { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
79
    { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
80
    { 13, 41 },  { 3, 62 },
81

    
82
    /* 70 -> 87 */
83
    { 0, 11 },   { 1, 55 },   { 0, 69 },     { -17, 127 },
84
    { -13, 102 },{ 0, 82 },   { -7, 74 },    { -21, 107 },
85
    { -27, 127 },{ -31, 127 },{ -24, 127 },  { -18, 95 },
86
    { -27, 127 },{ -21, 114 },{ -30, 127 },  { -17, 123 },
87
    { -12, 115 },{ -16, 122 },
88

    
89
    /* 88 -> 104 */
90
    { -11, 115 },{ -12, 63 }, { -2, 68 },    { -15, 84 },
91
    { -13, 104 },{ -3, 70 },  { -8, 93 },    { -10, 90 },
92
    { -30, 127 },{ -1, 74 },  { -6, 97 },    { -7, 91 },
93
    { -20, 127 },{ -4, 56 },  { -5, 82 },    { -7, 76 },
94
    { -22, 125 },
95

    
96
    /* 105 -> 135 */
97
    { -7, 93 },  { -11, 87 }, { -3, 77 },    { -5, 71 },
98
    { -4, 63 },  { -4, 68 },  { -12, 84 },   { -7, 62 },
99
    { -7, 65 },  { 8, 61 },   { 5, 56 },     { -2, 66 },
100
    { 1, 64 },   { 0, 61 },   { -2, 78 },    { 1, 50 },
101
    { 7, 52 },   { 10, 35 },  { 0, 44 },     { 11, 38 },
102
    { 1, 45 },   { 0, 46 },   { 5, 44 },     { 31, 17 },
103
    { 1, 51 },   { 7, 50 },   { 28, 19 },    { 16, 33 },
104
    { 14, 62 },  { -13, 108 },{ -15, 100 },
105

    
106
    /* 136 -> 165 */
107
    { -13, 101 },{ -13, 91 }, { -12, 94 },   { -10, 88 },
108
    { -16, 84 }, { -10, 86 }, { -7, 83 },    { -13, 87 },
109
    { -19, 94 }, { 1, 70 },   { 0, 72 },     { -5, 74 },
110
    { 18, 59 },  { -8, 102 }, { -15, 100 },  { 0, 95 },
111
    { -4, 75 },  { 2, 72 },   { -11, 75 },   { -3, 71 },
112
    { 15, 46 },  { -13, 69 }, { 0, 62 },     { 0, 65 },
113
    { 21, 37 },  { -15, 72 }, { 9, 57 },     { 16, 54 },
114
    { 0, 62 },   { 12, 72 },
115

    
116
    /* 166 -> 196 */
117
    { 24, 0 },   { 15, 9 },   { 8, 25 },     { 13, 18 },
118
    { 15, 9 },   { 13, 19 },  { 10, 37 },    { 12, 18 },
119
    { 6, 29 },   { 20, 33 },  { 15, 30 },    { 4, 45 },
120
    { 1, 58 },   { 0, 62 },   { 7, 61 },     { 12, 38 },
121
    { 11, 45 },  { 15, 39 },  { 11, 42 },    { 13, 44 },
122
    { 16, 45 },  { 12, 41 },  { 10, 49 },    { 30, 34 },
123
    { 18, 42 },  { 10, 55 },  { 17, 51 },    { 17, 46 },
124
    { 0, 89 },   { 26, -19 }, { 22, -17 },
125

    
126
    /* 197 -> 226 */
127
    { 26, -17 }, { 30, -25 }, { 28, -20 },   { 33, -23 },
128
    { 37, -27 }, { 33, -23 }, { 40, -28 },   { 38, -17 },
129
    { 33, -11 }, { 40, -15 }, { 41, -6 },    { 38, 1 },
130
    { 41, 17 },  { 30, -6 },  { 27, 3 },     { 26, 22 },
131
    { 37, -16 }, { 35, -4 },  { 38, -8 },    { 38, -3 },
132
    { 37, 3 },   { 38, 5 },   { 42, 0 },     { 35, 16 },
133
    { 39, 22 },  { 14, 48 },  { 27, 37 },    { 21, 60 },
134
    { 12, 68 },  { 2, 97 },
135

    
136
    /* 227 -> 251 */
137
    { -3, 71 },  { -6, 42 },  { -5, 50 },    { -3, 54 },
138
    { -2, 62 },  { 0, 58 },   { 1, 63 },     { -2, 72 },
139
    { -1, 74 },  { -9, 91 },  { -5, 67 },    { -5, 27 },
140
    { -3, 39 },  { -2, 44 },  { 0, 46 },     { -16, 64 },
141
    { -8, 68 },  { -10, 78 }, { -6, 77 },    { -10, 86 },
142
    { -12, 92 }, { -15, 55 }, { -10, 60 },   { -6, 62 },
143
    { -4, 65 },
144

    
145
    /* 252 -> 275 */
146
    { -12, 73 }, { -8, 76 },  { -7, 80 },    { -9, 88 },
147
    { -17, 110 },{ -11, 97 }, { -20, 84 },   { -11, 79 },
148
    { -6, 73 },  { -4, 74 },  { -13, 86 },   { -13, 96 },
149
    { -11, 97 }, { -19, 117 },{ -8, 78 },    { -5, 33 },
150
    { -4, 48 },  { -2, 53 },  { -3, 62 },    { -13, 71 },
151
    { -10, 79 }, { -12, 86 }, { -13, 90 },   { -14, 97 },
152

    
153
    /* 276 a bit special (not used, bypass is used instead) */
154
    { 0, 0 },
155

    
156
    /* 277 -> 307 */
157
    { -6, 93 },  { -6, 84 },  { -8, 79 },    { 0, 66 },
158
    { -1, 71 },  { 0, 62 },   { -2, 60 },    { -2, 59 },
159
    { -5, 75 },  { -3, 62 },  { -4, 58 },    { -9, 66 },
160
    { -1, 79 },  { 0, 71 },   { 3, 68 },     { 10, 44 },
161
    { -7, 62 },  { 15, 36 },  { 14, 40 },    { 16, 27 },
162
    { 12, 29 },  { 1, 44 },   { 20, 36 },    { 18, 32 },
163
    { 5, 42 },   { 1, 48 },   { 10, 62 },    { 17, 46 },
164
    { 9, 64 },   { -12, 104 },{ -11, 97 },
165

    
166
    /* 308 -> 337 */
167
    { -16, 96 }, { -7, 88 },  { -8, 85 },    { -7, 85 },
168
    { -9, 85 },  { -13, 88 }, { 4, 66 },     { -3, 77 },
169
    { -3, 76 },  { -6, 76 },  { 10, 58 },    { -1, 76 },
170
    { -1, 83 },  { -7, 99 },  { -14, 95 },   { 2, 95 },
171
    { 0, 76 },   { -5, 74 },  { 0, 70 },     { -11, 75 },
172
    { 1, 68 },   { 0, 65 },   { -14, 73 },   { 3, 62 },
173
    { 4, 62 },   { -1, 68 },  { -13, 75 },   { 11, 55 },
174
    { 5, 64 },   { 12, 70 },
175

    
176
    /* 338 -> 368 */
177
    { 15, 6 },   { 6, 19 },   { 7, 16 },     { 12, 14 },
178
    { 18, 13 },  { 13, 11 },  { 13, 15 },    { 15, 16 },
179
    { 12, 23 },  { 13, 23 },  { 15, 20 },    { 14, 26 },
180
    { 14, 44 },  { 17, 40 },  { 17, 47 },    { 24, 17 },
181
    { 21, 21 },  { 25, 22 },  { 31, 27 },    { 22, 29 },
182
    { 19, 35 },  { 14, 50 },  { 10, 57 },    { 7, 63 },
183
    { -2, 77 },  { -4, 82 },  { -3, 94 },    { 9, 69 },
184
    { -12, 109 },{ 36, -35 }, { 36, -34 },
185

    
186
    /* 369 -> 398 */
187
    { 32, -26 }, { 37, -30 }, { 44, -32 },   { 34, -18 },
188
    { 34, -15 }, { 40, -15 }, { 33, -7 },    { 35, -5 },
189
    { 33, 0 },   { 38, 2 },   { 33, 13 },    { 23, 35 },
190
    { 13, 58 },  { 29, -3 },  { 26, 0 },     { 22, 30 },
191
    { 31, -7 },  { 35, -15 }, { 34, -3 },    { 34, 3 },
192
    { 36, -1 },  { 34, 5 },   { 32, 11 },    { 35, 5 },
193
    { 34, 12 },  { 39, 11 },  { 30, 29 },    { 34, 26 },
194
    { 29, 39 },  { 19, 66 },
195

    
196
    /* 399 -> 435 */
197
    {  31,  21 }, {  31,  31 }, {  25,  50 },
198
    { -17, 120 }, { -20, 112 }, { -18, 114 }, { -11,  85 },
199
    { -15,  92 }, { -14,  89 }, { -26,  71 }, { -15,  81 },
200
    { -14,  80 }, {   0,  68 }, { -14,  70 }, { -24,  56 },
201
    { -23,  68 }, { -24,  50 }, { -11,  74 }, {  23, -13 },
202
    {  26, -13 }, {  40, -15 }, {  49, -14 }, {  44,   3 },
203
    {  45,   6 }, {  44,  34 }, {  33,  54 }, {  19,  82 },
204
    {  -3,  75 }, {  -1,  23 }, {   1,  34 }, {   1,  43 },
205
    {   0,  54 }, {  -2,  55 }, {   0,  61 }, {   1,  64 },
206
    {   0,  68 }, {  -9,  92 },
207

    
208
    /* 436 -> 459 */
209
    { -14, 106 }, { -13,  97 }, { -15,  90 }, { -12,  90 },
210
    { -18,  88 }, { -10,  73 }, {  -9,  79 }, { -14,  86 },
211
    { -10,  73 }, { -10,  70 }, { -10,  69 }, {  -5,  66 },
212
    {  -9,  64 }, {  -5,  58 }, {   2,  59 }, {  21, -10 },
213
    {  24, -11 }, {  28,  -8 }, {  28,  -1 }, {  29,   3 },
214
    {  29,   9 }, {  35,  20 }, {  29,  36 }, {  14,  67 }
215
};
216

    
217
static const int8_t cabac_context_init_PB[3][460][2] =
218
{
219
    /* i_cabac_init_idc == 0 */
220
    {
221
        /* 0 - 10 */
222
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
223
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
224
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
225

    
226
        /* 11 - 23 */
227
        {  23,  33 }, {  23,   2 }, {  21,   0 }, {   1,   9 },
228
        {   0,  49 }, { -37, 118 }, {   5,  57 }, { -13,  78 },
229
        { -11,  65 }, {   1,  62 }, {  12,  49 }, {  -4,  73 },
230
        {  17,  50 },
231

    
232
        /* 24 - 39 */
233
        {  18,  64 }, {   9,  43 }, {  29,   0 }, {  26,  67 },
234
        {  16,  90 }, {   9, 104 }, { -46, 127 }, { -20, 104 },
235
        {   1,  67 }, { -13,  78 }, { -11,  65 }, {   1,  62 },
236
        {  -6,  86 }, { -17,  95 }, {  -6,  61 }, {   9,  45 },
237

    
238
        /* 40 - 53 */
239
        {  -3,  69 }, {  -6,  81 }, { -11,  96 }, {   6,  55 },
240
        {   7,  67 }, {  -5,  86 }, {   2,  88 }, {   0,  58 },
241
        {  -3,  76 }, { -10,  94 }, {   5,  54 }, {   4,  69 },
242
        {  -3,  81 }, {   0,  88 },
243

    
244
        /* 54 - 59 */
245
        {  -7,  67 }, {  -5,  74 }, {  -4,  74 }, {  -5,  80 },
246
        {  -7,  72 }, {   1,  58 },
247

    
248
        /* 60 - 69 */
249
        {   0,  41 }, {   0,  63 }, {   0,  63 }, { 0, 63 },
250
        {  -9,  83 }, {   4,  86 }, {   0,  97 }, { -7, 72 },
251
        {  13,  41 }, {   3,  62 },
252

    
253
        /* 70 - 87 */
254
        {   0,  45 }, {  -4,  78 }, {  -3,  96 }, { -27,  126 },
255
        { -28,  98 }, { -25, 101 }, { -23,  67 }, { -28,  82 },
256
        { -20,  94 }, { -16,  83 }, { -22, 110 }, { -21,  91 },
257
        { -18, 102 }, { -13,  93 }, { -29, 127 }, {  -7,  92 },
258
        {  -5,  89 }, {  -7,  96 }, { -13, 108 }, {  -3,  46 },
259
        {  -1,  65 }, {  -1,  57 }, {  -9,  93 }, {  -3,  74 },
260
        {  -9,  92 }, {  -8,  87 }, { -23, 126 }, {   5,  54 },
261
        {   6,  60 }, {   6,  59 }, {   6,  69 }, {  -1,  48 },
262
        {   0,  68 }, {  -4,  69 }, {  -8,  88 },
263

    
264
        /* 105 -> 165 */
265
        {  -2,  85 }, {  -6,  78 }, {  -1,  75 }, {  -7,  77 },
266
        {   2,  54 }, {   5,  50 }, {  -3,  68 }, {   1,  50 },
267
        {   6,  42 }, {  -4,  81 }, {   1,  63 }, {  -4,  70 },
268
        {   0,  67 }, {   2,  57 }, {  -2,  76 }, {  11,  35 },
269
        {   4,  64 }, {   1,  61 }, {  11,  35 }, {  18,  25 },
270
        {  12,  24 }, {  13,  29 }, {  13,  36 }, { -10,  93 },
271
        {  -7,  73 }, {  -2,  73 }, {  13,  46 }, {   9,  49 },
272
        {  -7, 100 }, {   9,  53 }, {   2,  53 }, {   5,  53 },
273
        {  -2,  61 }, {   0,  56 }, {   0,  56 }, { -13,  63 },
274
        {  -5,  60 }, {  -1,  62 }, {   4,  57 }, {  -6,  69 },
275
        {   4,  57 }, {  14,  39 }, {   4,  51 }, {  13,  68 },
276
        {   3,  64 }, {   1,  61 }, {   9,  63 }, {   7,  50 },
277
        {  16,  39 }, {   5,  44 }, {   4,  52 }, {  11,  48 },
278
        {  -5,  60 }, {  -1,  59 }, {   0,  59 }, {  22,  33 },
279
        {   5,  44 }, {  14,  43 }, {  -1,  78 }, {   0,  60 },
280
        {   9,  69 },
281

    
282
        /* 166 - 226 */
283
        {  11,  28 }, {   2,  40 }, {   3,  44 }, {   0,  49 },
284
        {   0,  46 }, {   2,  44 }, {   2,  51 }, {   0,  47 },
285
        {   4,  39 }, {   2,  62 }, {   6,  46 }, {   0,  54 },
286
        {   3,  54 }, {   2,  58 }, {   4,  63 }, {   6,  51 },
287
        {   6,  57 }, {   7,  53 }, {   6,  52 }, {   6,  55 },
288
        {  11,  45 }, {  14,  36 }, {   8,  53 }, {  -1,  82 },
289
        {   7,  55 }, {  -3,  78 }, {  15,  46 }, {  22,  31 },
290
        {  -1,  84 }, {  25,   7 }, {  30,  -7 }, {  28,   3 },
291
        {  28,   4 }, {  32,   0 }, {  34,  -1 }, {  30,   6 },
292
        {  30,   6 }, {  32,   9 }, {  31,  19 }, {  26,  27 },
293
        {  26,  30 }, {  37,  20 }, {  28,  34 }, {  17,  70 },
294
        {   1,  67 }, {   5,  59 }, {   9,  67 }, {  16,  30 },
295
        {  18,  32 }, {  18,  35 }, {  22,  29 }, {  24,  31 },
296
        {  23,  38 }, {  18,  43 }, {  20,  41 }, {  11,  63 },
297
        {   9,  59 }, {   9,  64 }, {  -1,  94 }, {  -2,  89 },
298
        {  -9, 108 },
299

    
300
        /* 227 - 275 */
301
        {  -6,  76 }, {  -2,  44 }, {   0,  45 }, {   0,  52 },
302
        {  -3,  64 }, {  -2,  59 }, {  -4,  70 }, {  -4,  75 },
303
        {  -8,  82 }, { -17, 102 }, {  -9,  77 }, {   3,  24 },
304
        {   0,  42 }, {   0,  48 }, {   0,  55 }, {  -6,  59 },
305
        {  -7,  71 }, { -12,  83 }, { -11,  87 }, { -30, 119 },
306
        {   1,  58 }, {  -3,  29 }, {  -1,  36 }, {   1,  38 },
307
        {   2,  43 }, {  -6,  55 }, {   0,  58 }, {   0,  64 },
308
        {  -3,  74 }, { -10,  90 }, {   0,  70 }, {  -4,  29 },
309
        {   5,  31 }, {   7,  42 }, {   1,  59 }, {  -2,  58 },
310
        {  -3,  72 }, {  -3,  81 }, { -11,  97 }, {   0,  58 },
311
        {   8,   5 }, {  10,  14 }, {  14,  18 }, {  13,  27 },
312
        {   2,  40 }, {   0,  58 }, {  -3,  70 }, {  -6,  79 },
313
        {  -8,  85 },
314

    
315
        /* 276 a bit special (not used, bypass is used instead) */
316
        { 0, 0 },
317

    
318
        /* 277 - 337 */
319
        { -13, 106 }, { -16, 106 }, { -10,  87 }, { -21, 114 },
320
        { -18, 110 }, { -14,  98 }, { -22, 110 }, { -21, 106 },
321
        { -18, 103 }, { -21, 107 }, { -23, 108 }, { -26, 112 },
322
        { -10,  96 }, { -12,  95 }, {  -5,  91 }, {  -9,  93 },
323
        { -22,  94 }, {  -5,  86 }, {   9,  67 }, {  -4,  80 },
324
        { -10,  85 }, {  -1,  70 }, {   7,  60 }, {   9,  58 },
325
        {   5,  61 }, {  12,  50 }, {  15,  50 }, {  18,  49 },
326
        {  17,  54 }, {  10,  41 }, {   7,  46 }, {  -1,  51 },
327
        {   7,  49 }, {   8,  52 }, {   9,  41 }, {   6,  47 },
328
        {   2,  55 }, {  13,  41 }, {  10,  44 }, {   6,  50 },
329
        {   5,  53 }, {  13,  49 }, {   4,  63 }, {   6,  64 },
330
        {  -2,  69 }, {  -2,  59 }, {   6,  70 }, {  10,  44 },
331
        {   9,  31 }, {  12,  43 }, {   3,  53 }, {  14,  34 },
332
        {  10,  38 }, {  -3,  52 }, {  13,  40 }, {  17,  32 },
333
        {   7,  44 }, {   7,  38 }, {  13,  50 }, {  10,  57 },
334
        {  26,  43 },
335

    
336
        /* 338 - 398 */
337
        {  14,  11 }, {  11,  14 }, {   9,  11 }, {  18,  11 },
338
        {  21,   9 }, {  23,  -2 }, {  32, -15 }, {  32, -15 },
339
        {  34, -21 }, {  39, -23 }, {  42, -33 }, {  41, -31 },
340
        {  46, -28 }, {  38, -12 }, {  21,  29 }, {  45, -24 },
341
        {  53, -45 }, {  48, -26 }, {  65, -43 }, {  43, -19 },
342
        {  39, -10 }, {  30,   9 }, {  18,  26 }, {  20,  27 },
343
        {   0,  57 }, { -14,  82 }, {  -5,  75 }, { -19,  97 },
344
        { -35, 125 }, {  27,   0 }, {  28,   0 }, {  31,  -4 },
345
        {  27,   6 }, {  34,   8 }, {  30,  10 }, {  24,  22 },
346
        {  33,  19 }, {  22,  32 }, {  26,  31 }, {  21,  41 },
347
        {  26,  44 }, {  23,  47 }, {  16,  65 }, {  14,  71 },
348
        {   8,  60 }, {   6,  63 }, {  17,  65 }, {  21,  24 },
349
        {  23,  20 }, {  26,  23 }, {  27,  32 }, {  28,  23 },
350
        {  28,  24 }, {  23,  40 }, {  24,  32 }, {  28,  29 },
351
        {  23,  42 }, {  19,  57 }, {  22,  53 }, {  22,  61 },
352
        {  11,  86 },
353

    
354
        /* 399 - 435 */
355
        {  12,  40 }, {  11,  51 }, {  14,  59 },
356
        {  -4,  79 }, {  -7,  71 }, {  -5,  69 }, {  -9,  70 },
357
        {  -8,  66 }, { -10,  68 }, { -19,  73 }, { -12,  69 },
358
        { -16,  70 }, { -15,  67 }, { -20,  62 }, { -19,  70 },
359
        { -16,  66 }, { -22,  65 }, { -20,  63 }, {   9,  -2 },
360
        {  26,  -9 }, {  33,  -9 }, {  39,  -7 }, {  41,  -2 },
361
        {  45,   3 }, {  49,   9 }, {  45,  27 }, {  36,  59 },
362
        {  -6,  66 }, {  -7,  35 }, {  -7,  42 }, {  -8,  45 },
363
        {  -5,  48 }, { -12,  56 }, {  -6,  60 }, {  -5,  62 },
364
        {  -8,  66 }, {  -8,  76 },
365

    
366
        /* 436 - 459 */
367
        {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
368
        { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
369
        {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
370
        { -14,  66 }, {   0,  59 }, {   2,  59 }, {  21, -13 },
371
        {  33, -14 }, {  39,  -7 }, {  46,  -2 }, {  51,   2 },
372
        {  60,   6 }, {  61,  17 }, {  55,  34 }, {  42,  62 },
373
    },
374

    
375
    /* i_cabac_init_idc == 1 */
376
    {
377
        /* 0 - 10 */
378
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
379
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
380
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
381

    
382
        /* 11 - 23 */
383
        {  22,  25 }, {  34,   0 }, {  16,   0 }, {  -2,   9 },
384
        {   4,  41 }, { -29, 118 }, {   2,  65 }, {  -6,  71 },
385
        { -13,  79 }, {   5,  52 }, {   9,  50 }, {  -3,  70 },
386
        {  10,  54 },
387

    
388
        /* 24 - 39 */
389
        {  26,  34 }, {  19,  22 }, {  40,   0 }, {  57,   2 },
390
        {  41,  36 }, {  26,  69 }, { -45, 127 }, { -15, 101 },
391
        {  -4,  76 }, {  -6,  71 }, { -13,  79 }, {   5,  52 },
392
        {   6,  69 }, { -13,  90 }, {   0,  52 }, {   8,  43 },
393

    
394
        /* 40 - 53 */
395
        {  -2,  69 },{  -5,  82 },{ -10,  96 },{   2,  59 },
396
        {   2,  75 },{  -3,  87 },{  -3,  100 },{   1,  56 },
397
        {  -3,  74 },{  -6,  85 },{   0,  59 },{  -3,  81 },
398
        {  -7,  86 },{  -5,  95 },
399

    
400
        /* 54 - 59 */
401
        {  -1,  66 },{  -1,  77 },{   1,  70 },{  -2,  86 },
402
        {  -5,  72 },{   0,  61 },
403

    
404
        /* 60 - 69 */
405
        { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
406
        { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
407
        { 13, 41 },  { 3, 62 },
408

    
409
        /* 70 - 104 */
410
        {  13,  15 }, {   7,  51 }, {   2,  80 }, { -39, 127 },
411
        { -18,  91 }, { -17,  96 }, { -26,  81 }, { -35,  98 },
412
        { -24, 102 }, { -23,  97 }, { -27, 119 }, { -24,  99 },
413
        { -21, 110 }, { -18, 102 }, { -36, 127 }, {   0,  80 },
414
        {  -5,  89 }, {  -7,  94 }, {  -4,  92 }, {   0,  39 },
415
        {   0,  65 }, { -15,  84 }, { -35, 127 }, {  -2,  73 },
416
        { -12, 104 }, {  -9,  91 }, { -31, 127 }, {   3,  55 },
417
        {   7,  56 }, {   7,  55 }, {   8,  61 }, {  -3,  53 },
418
        {   0,  68 }, {  -7,  74 }, {  -9,  88 },
419

    
420
        /* 105 -> 165 */
421
        { -13, 103 }, { -13,  91 }, {  -9,  89 }, { -14,  92 },
422
        {  -8,  76 }, { -12,  87 }, { -23, 110 }, { -24, 105 },
423
        { -10,  78 }, { -20, 112 }, { -17,  99 }, { -78, 127 },
424
        { -70, 127 }, { -50, 127 }, { -46, 127 }, {  -4,  66 },
425
        {  -5,  78 }, {  -4,  71 }, {  -8,  72 }, {   2,  59 },
426
        {  -1,  55 }, {  -7,  70 }, {  -6,  75 }, {  -8,  89 },
427
        { -34, 119 }, {  -3,  75 }, {  32,  20 }, {  30,  22 },
428
        { -44, 127 }, {   0,  54 }, {  -5,  61 }, {   0,  58 },
429
        {  -1,  60 }, {  -3,  61 }, {  -8,  67 }, { -25,  84 },
430
        { -14,  74 }, {  -5,  65 }, {   5,  52 }, {   2,  57 },
431
        {   0,  61 }, {  -9,  69 }, { -11,  70 }, {  18,  55 },
432
        {  -4,  71 }, {   0,  58 }, {   7,  61 }, {   9,  41 },
433
        {  18,  25 }, {   9,  32 }, {   5,  43 }, {   9,  47 },
434
        {   0,  44 }, {   0,  51 }, {   2,  46 }, {  19,  38 },
435
        {  -4,  66 }, {  15,  38 }, {  12,  42 }, {   9,  34 },
436
        {   0,  89 },
437

    
438
        /* 166 - 226 */
439
        {   4,  45 }, {  10,  28 }, {  10,  31 }, {  33, -11 },
440
        {  52, -43 }, {  18,  15 }, {  28,   0 }, {  35, -22 },
441
        {  38, -25 }, {  34,   0 }, {  39, -18 }, {  32, -12 },
442
        { 102, -94 }, {   0,   0 }, {  56, -15 }, {  33,  -4 },
443
        {  29,  10 }, {  37,  -5 }, {  51, -29 }, {  39,  -9 },
444
        {  52, -34 }, {  69, -58 }, {  67, -63 }, {  44,  -5 },
445
        {  32,   7 }, {  55, -29 }, {  32,   1 }, {   0,   0 },
446
        {  27,  36 }, {  33, -25 }, {  34, -30 }, {  36, -28 },
447
        {  38, -28 }, {  38, -27 }, {  34, -18 }, {  35, -16 },
448
        {  34, -14 }, {  32,  -8 }, {  37,  -6 }, {  35,   0 },
449
        {  30,  10 }, {  28,  18 }, {  26,  25 }, {  29,  41 },
450
        {   0,  75 }, {   2,  72 }, {   8,  77 }, {  14,  35 },
451
        {  18,  31 }, {  17,  35 }, {  21,  30 }, {  17,  45 },
452
        {  20,  42 }, {  18,  45 }, {  27,  26 }, {  16,  54 },
453
        {   7,  66 }, {  16,  56 }, {  11,  73 }, {  10,  67 },
454
        { -10, 116 },
455

    
456
        /* 227 - 275 */
457
        { -23, 112 }, { -15,  71 }, {  -7,  61 }, {   0,  53 },
458
        {  -5,  66 }, { -11,  77 }, {  -9,  80 }, {  -9,  84 },
459
        { -10,  87 }, { -34, 127 }, { -21, 101 }, {  -3,  39 },
460
        {  -5,  53 }, {  -7,  61 }, { -11,  75 }, { -15,  77 },
461
        { -17,  91 }, { -25, 107 }, { -25, 111 }, { -28, 122 },
462
        { -11,  76 }, { -10,  44 }, { -10,  52 }, { -10,  57 },
463
        {  -9,  58 }, { -16,  72 }, {  -7,  69 }, {  -4,  69 },
464
        {  -5,  74 }, {  -9,  86 }, {   2,  66 }, {  -9,  34 },
465
        {   1,  32 }, {  11,  31 }, {   5,  52 }, {  -2,  55 },
466
        {  -2,  67 }, {   0,  73 }, {  -8,  89 }, {   3,  52 },
467
        {   7,   4 }, {  10,   8 }, {  17,   8 }, {  16,  19 },
468
        {   3,  37 }, {  -1,  61 }, {  -5,  73 }, {  -1,  70 },
469
        {  -4,  78 },
470

    
471
        /* 276 a bit special (not used, bypass is used instead) */
472
        { 0, 0 },
473

    
474
        /* 277 - 337 */
475
        { -21, 126 }, { -23, 124 }, { -20, 110 }, { -26, 126 },
476
        { -25, 124 }, { -17, 105 }, { -27, 121 }, { -27, 117 },
477
        { -17, 102 }, { -26, 117 }, { -27, 116 }, { -33, 122 },
478
        { -10,  95 }, { -14, 100 }, {  -8,  95 }, { -17, 111 },
479
        { -28, 114 }, {  -6,  89 }, {  -2,  80 }, {  -4,  82 },
480
        {  -9,  85 }, {  -8,  81 }, {  -1,  72 }, {   5,  64 },
481
        {   1,  67 }, {   9,  56 }, {   0,  69 }, {   1,  69 },
482
        {   7,  69 }, {  -7,  69 }, {  -6,  67 }, { -16,  77 },
483
        {  -2,  64 }, {   2,  61 }, {  -6,  67 }, {  -3,  64 },
484
        {   2,  57 }, {  -3,  65 }, {  -3,  66 }, {   0,  62 },
485
        {   9,  51 }, {  -1,  66 }, {  -2,  71 }, {  -2,  75 },
486
        {  -1,  70 }, {  -9,  72 }, {  14,  60 }, {  16,  37 },
487
        {   0,  47 }, {  18,  35 }, {  11,  37 }, {  12,  41 },
488
        {  10,  41 }, {   2,  48 }, {  12,  41 }, {  13,  41 },
489
        {   0,  59 }, {   3,  50 }, {  19,  40 }, {   3,  66 },
490
        {  18,  50 },
491

    
492
        /* 338 - 398 */
493
        {  19,  -6 }, {  18,  -6 }, {  14,   0 }, {  26, -12 },
494
        {  31, -16 }, {  33, -25 }, {  33, -22 }, {  37, -28 },
495
        {  39, -30 }, {  42, -30 }, {  47, -42 }, {  45, -36 },
496
        {  49, -34 }, {  41, -17 }, {  32,   9 }, {  69, -71 },
497
        {  63, -63 }, {  66, -64 }, {  77, -74 }, {  54, -39 },
498
        {  52, -35 }, {  41, -10 }, {  36,   0 }, {  40,  -1 },
499
        {  30,  14 }, {  28,  26 }, {  23,  37 }, {  12,  55 },
500
        {  11,  65 }, {  37, -33 }, {  39, -36 }, {  40, -37 },
501
        {  38, -30 }, {  46, -33 }, {  42, -30 }, {  40, -24 },
502
        {  49, -29 }, {  38, -12 }, {  40, -10 }, {  38,  -3 },
503
        {  46,  -5 }, {  31,  20 }, {  29,  30 }, {  25,  44 },
504
        {  12,  48 }, {  11,  49 }, {  26,  45 }, {  22,  22 },
505
        {  23,  22 }, {  27,  21 }, {  33,  20 }, {  26,  28 },
506
        {  30,  24 }, {  27,  34 }, {  18,  42 }, {  25,  39 },
507
        {  18,  50 }, {  12,  70 }, {  21,  54 }, {  14,  71 },
508
        {  11,  83 },
509

    
510
        /* 399 - 435 */
511
        {  25,  32 }, {  21,  49 }, {  21,  54 },
512
        {  -5,  85 }, {  -6,  81 }, { -10,  77 }, {  -7,  81 },
513
        { -17,  80 }, { -18,  73 }, {  -4,  74 }, { -10,  83 },
514
        {  -9,  71 }, {  -9,  67 }, {  -1,  61 }, {  -8,  66 },
515
        { -14,  66 }, {   0,  59 }, {   2,  59 }, {  17, -10 },
516
        {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
517
        {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
518
        {  -5,  71 }, {   0,  24 }, {  -1,  36 }, {  -2,  42 },
519
        {  -2,  52 }, {  -9,  57 }, {  -6,  63 }, {  -4,  65 },
520
        {  -4,  67 }, {  -7,  82 },
521

    
522
        /* 436 - 459 */
523
        {  -3,  81 }, {  -3,  76 }, {  -7,  72 }, {  -6,  78 },
524
        { -12,  72 }, { -14,  68 }, {  -3,  70 }, {  -6,  76 },
525
        {  -5,  66 }, {  -5,  62 }, {   0,  57 }, {  -4,  61 },
526
        {  -9,  60 }, {   1,  54 }, {   2,  58 }, {  17, -10 },
527
        {  32, -13 }, {  42,  -9 }, {  49,  -5 }, {  53,   0 },
528
        {  64,   3 }, {  68,  10 }, {  66,  27 }, {  47,  57 },
529
    },
530

    
531
    /* i_cabac_init_idc == 2 */
532
    {
533
        /* 0 - 10 */
534
        {  20, -15 }, {   2,  54 }, {   3,  74 }, {  20, -15 },
535
        {   2,  54 }, {   3,  74 }, { -28, 127 }, { -23, 104 },
536
        {  -6,  53 }, {  -1,  54 }, {   7,  51 },
537

    
538
        /* 11 - 23 */
539
        {  29,  16 }, {  25,   0 }, {  14,   0 }, { -10,  51 },
540
        {  -3,  62 }, { -27,  99 }, {  26,  16 }, {  -4,  85 },
541
        { -24, 102 }, {   5,  57 }, {   6,  57 }, { -17,  73 },
542
        {  14,  57 },
543

    
544
        /* 24 - 39 */
545
        {  20,  40 }, {  20,  10 }, {  29,   0 }, {  54,   0 },
546
        {  37,  42 }, {  12,  97 }, { -32, 127 }, { -22, 117 },
547
        {  -2,  74 }, {  -4,  85 }, { -24, 102 }, {   5,  57 },
548
        {  -6,  93 }, { -14,  88 }, {  -6,  44 }, {   4,  55 },
549

    
550
        /* 40 - 53 */
551
        { -11,  89 },{ -15,  103 },{ -21,  116 },{  19,  57 },
552
        {  20,  58 },{   4,  84 },{   6,  96 },{   1,  63 },
553
        {  -5,  85 },{ -13,  106 },{   5,  63 },{   6,  75 },
554
        {  -3,  90 },{  -1,  101 },
555

    
556
        /* 54 - 59 */
557
        {   3,  55 },{  -4,  79 },{  -2,  75 },{ -12,  97 },
558
        {  -7,  50 },{   1,  60 },
559

    
560
        /* 60 - 69 */
561
        { 0, 41 },   { 0, 63 },   { 0, 63 },     { 0, 63 },
562
        { -9, 83 },  { 4, 86 },   { 0, 97 },     { -7, 72 },
563
        { 13, 41 },  { 3, 62 },
564

    
565
        /* 70 - 104 */
566
        {   7,  34 }, {  -9,  88 }, { -20, 127 }, { -36, 127 },
567
        { -17,  91 }, { -14,  95 }, { -25,  84 }, { -25,  86 },
568
        { -12,  89 }, { -17,  91 }, { -31, 127 }, { -14,  76 },
569
        { -18, 103 }, { -13,  90 }, { -37, 127 }, {  11,  80 },
570
        {   5,  76 }, {   2,  84 }, {   5,  78 }, {  -6,  55 },
571
        {   4,  61 }, { -14,  83 }, { -37, 127 }, {  -5,  79 },
572
        { -11, 104 }, { -11,  91 }, { -30, 127 }, {   0,  65 },
573
        {  -2,  79 }, {   0,  72 }, {  -4,  92 }, {  -6,  56 },
574
        {   3,  68 }, {  -8,  71 }, { -13,  98 },
575

    
576
        /* 105 -> 165 */
577
        {  -4,  86 }, { -12,  88 }, {  -5,  82 }, {  -3,  72 },
578
        {  -4,  67 }, {  -8,  72 }, { -16,  89 }, {  -9,  69 },
579
        {  -1,  59 }, {   5,  66 }, {   4,  57 }, {  -4,  71 },
580
        {  -2,  71 }, {   2,  58 }, {  -1,  74 }, {  -4,  44 },
581
        {  -1,  69 }, {   0,  62 }, {  -7,  51 }, {  -4,  47 },
582
        {  -6,  42 }, {  -3,  41 }, {  -6,  53 }, {   8,  76 },
583
        {  -9,  78 }, { -11,  83 }, {   9,  52 }, {   0,  67 },
584
        {  -5,  90 }, {   1,  67 }, { -15,  72 }, {  -5,  75 },
585
        {  -8,  80 }, { -21,  83 }, { -21,  64 }, { -13,  31 },
586
        { -25,  64 }, { -29,  94 }, {   9,  75 }, {  17,  63 },
587
        {  -8,  74 }, {  -5,  35 }, {  -2,  27 }, {  13,  91 },
588
        {   3,  65 }, {  -7,  69 }, {   8,  77 }, { -10,  66 },
589
        {   3,  62 }, {  -3,  68 }, { -20,  81 }, {   0,  30 },
590
        {   1,   7 }, {  -3,  23 }, { -21,  74 }, {  16,  66 },
591
        { -23, 124 }, {  17,  37 }, {  44, -18 }, {  50, -34 },
592
        { -22, 127 },
593

    
594
        /* 166 - 226 */
595
        {   4,  39 }, {   0,  42 }, {   7,  34 }, {  11,  29 },
596
        {   8,  31 }, {   6,  37 }, {   7,  42 }, {   3,  40 },
597
        {   8,  33 }, {  13,  43 }, {  13,  36 }, {   4,  47 },
598
        {   3,  55 }, {   2,  58 }, {   6,  60 }, {   8,  44 },
599
        {  11,  44 }, {  14,  42 }, {   7,  48 }, {   4,  56 },
600
        {   4,  52 }, {  13,  37 }, {   9,  49 }, {  19,  58 },
601
        {  10,  48 }, {  12,  45 }, {   0,  69 }, {  20,  33 },
602
        {   8,  63 }, {  35, -18 }, {  33, -25 }, {  28,  -3 },
603
        {  24,  10 }, {  27,   0 }, {  34, -14 }, {  52, -44 },
604
        {  39, -24 }, {  19,  17 }, {  31,  25 }, {  36,  29 },
605
        {  24,  33 }, {  34,  15 }, {  30,  20 }, {  22,  73 },
606
        {  20,  34 }, {  19,  31 }, {  27,  44 }, {  19,  16 },
607
        {  15,  36 }, {  15,  36 }, {  21,  28 }, {  25,  21 },
608
        {  30,  20 }, {  31,  12 }, {  27,  16 }, {  24,  42 },
609
        {   0,  93 }, {  14,  56 }, {  15,  57 }, {  26,  38 },
610
        { -24, 127 },
611

    
612
        /* 227 - 275 */
613
        { -24, 115 }, { -22,  82 }, {  -9,  62 }, {   0,  53 },
614
        {   0,  59 }, { -14,  85 }, { -13,  89 }, { -13,  94 },
615
        { -11,  92 }, { -29, 127 }, { -21, 100 }, { -14,  57 },
616
        { -12,  67 }, { -11,  71 }, { -10,  77 }, { -21,  85 },
617
        { -16,  88 }, { -23, 104 }, { -15,  98 }, { -37, 127 },
618
        { -10,  82 }, {  -8,  48 }, {  -8,  61 }, {  -8,  66 },
619
        {  -7,  70 }, { -14,  75 }, { -10,  79 }, {  -9,  83 },
620
        { -12,  92 }, { -18, 108 }, {  -4,  79 }, { -22,  69 },
621
        { -16,  75 }, {  -2,  58 }, {   1,  58 }, { -13,  78 },
622
        {  -9,  83 }, {  -4,  81 }, { -13,  99 }, { -13,  81 },
623
        {  -6,  38 }, { -13,  62 }, {  -6,  58 }, {  -2,  59 },
624
        { -16,  73 }, { -10,  76 }, { -13,  86 }, {  -9,  83 },
625
        { -10,  87 },
626

    
627
        /* 276 a bit special (not used, bypass is used instead) */
628
        { 0, 0 },
629

    
630
        /* 277 - 337 */
631
        { -22, 127 }, { -25, 127 }, { -25, 120 }, { -27, 127 },
632
        { -19, 114 }, { -23, 117 }, { -25, 118 }, { -26, 117 },
633
        { -24, 113 }, { -28, 118 }, { -31, 120 }, { -37, 124 },
634
        { -10,  94 }, { -15, 102 }, { -10,  99 }, { -13, 106 },
635
        { -50, 127 }, {  -5,  92 }, {  17,  57 }, {  -5,  86 },
636
        { -13,  94 }, { -12,  91 }, {  -2,  77 }, {   0,  71 },
637
        {  -1,  73 }, {   4,  64 }, {  -7,  81 }, {   5,  64 },
638
        {  15,  57 }, {   1,  67 }, {   0,  68 }, { -10,  67 },
639
        {   1,  68 }, {   0,  77 }, {   2,  64 }, {   0,  68 },
640
        {  -5,  78 }, {   7,  55 }, {   5,  59 }, {   2,  65 },
641
        {  14,  54 }, {  15,  44 }, {   5,  60 }, {   2,  70 },
642
        {  -2,  76 }, { -18,  86 }, {  12,  70 }, {   5,  64 },
643
        { -12,  70 }, {  11,  55 }, {   5,  56 }, {   0,  69 },
644
        {   2,  65 }, {  -6,  74 }, {   5,  54 }, {   7,  54 },
645
        {  -6,  76 }, { -11,  82 }, {  -2,  77 }, {  -2,  77 },
646
        {  25,  42 },
647

    
648
        /* 338 - 398 */
649
        {  17, -13 }, {  16,  -9 }, {  17, -12 }, {  27, -21 },
650
        {  37, -30 }, {  41, -40 }, {  42, -41 }, {  48, -47 },
651
        {  39, -32 }, {  46, -40 }, {  52, -51 }, {  46, -41 },
652
        {  52, -39 }, {  43, -19 }, {  32,  11 }, {  61, -55 },
653
        {  56, -46 }, {  62, -50 }, {  81, -67 }, {  45, -20 },
654
        {  35,  -2 }, {  28,  15 }, {  34,   1 }, {  39,   1 },
655
        {  30,  17 }, {  20,  38 }, {  18,  45 }, {  15,  54 },
656
        {   0,  79 }, {  36, -16 }, {  37, -14 }, {  37, -17 },
657
        {  32,   1 }, {  34,  15 }, {  29,  15 }, {  24,  25 },
658
        {  34,  22 }, {  31,  16 }, {  35,  18 }, {  31,  28 },
659
        {  33,  41 }, {  36,  28 }, {  27,  47 }, {  21,  62 },
660
        {  18,  31 }, {  19,  26 }, {  36,  24 }, {  24,  23 },
661
        {  27,  16 }, {  24,  30 }, {  31,  29 }, {  22,  41 },
662
        {  22,  42 }, {  16,  60 }, {  15,  52 }, {  14,  60 },
663
        {   3,  78 }, { -16, 123 }, {  21,  53 }, {  22,  56 },
664
        {  25,  61 },
665

    
666
        /* 399 - 435 */
667
        {  21,  33 }, {  19,  50 }, {  17,  61 },
668
        {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
669
        { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
670
        { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
671
        { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
672
        {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
673
        {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
674
        {  -9,  71 }, {  -7,  37 }, {  -8,  44 }, { -11,  49 },
675
        { -10,  56 }, { -12,  59 }, {  -8,  63 }, {  -9,  67 },
676
        {  -6,  68 }, { -10,  79 },
677

    
678
        /* 436 - 459 */
679
        {  -3,  78 }, {  -8,  74 }, {  -9,  72 }, { -10,  72 },
680
        { -18,  75 }, { -12,  71 }, { -11,  63 }, {  -5,  70 },
681
        { -17,  75 }, { -14,  72 }, { -16,  67 }, {  -8,  53 },
682
        { -14,  59 }, {  -9,  52 }, { -11,  68 }, {   9,  -2 },
683
        {  30, -10 }, {  31,  -4 }, {  33,  -1 }, {  33,   7 },
684
        {  31,  12 }, {  37,  23 }, {  31,  38 }, {  20,  64 },
685
    }
686
};
687

    
688
void ff_h264_init_cabac_states(H264Context *h) {
689
    MpegEncContext * const s = &h->s;
690
    int i;
691

    
692
    /* calculate pre-state */
693
    for( i= 0; i < 460; i++ ) {
694
        int pre;
695
        if( h->slice_type_nos == FF_I_TYPE )
696
            pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
697
        else
698
            pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
699

    
700
        if( pre <= 63 )
701
            h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
702
        else
703
            h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
704
    }
705
}
706

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

    
712
    unsigned long ctx = 0;
713

    
714
    ctx += (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
        MpegEncContext * const s = &h->s;
726
        const int mba_xy = h->left_mb_xy[0];
727
        const int mbb_xy = h->top_mb_xy;
728
        int ctx=0;
729
        if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
730
            ctx++;
731
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
732
            ctx++;
733
        if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
734
            return 0;   /* I4x4 */
735
        state += 2;
736
    }else{
737
        if( get_cabac_noinline( &h->cabac, state ) == 0 )
738
            return 0;   /* I4x4 */
739
    }
740

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

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

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

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

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

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

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

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

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

    
799
    if( mode >= pred_mode )
800
        return mode + 1;
801
    else
802
        return mode;
803
}
804

    
805
static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
806
    const int mba_xy = h->left_mb_xy[0];
807
    const int mbb_xy = h->top_mb_xy;
808

    
809
    int ctx = 0;
810

    
811
    /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
812
    if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
813
        ctx++;
814

    
815
    if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
816
        ctx++;
817

    
818
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
819
        return 0;
820

    
821
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
822
        return 1;
823
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
824
        return 2;
825
    else
826
        return 3;
827
}
828

    
829
static int decode_cabac_mb_cbp_luma( H264Context *h) {
830
    int cbp_b, cbp_a, ctx, cbp = 0;
831

    
832
    cbp_a = h->left_cbp;
833
    cbp_b = h->top_cbp;
834

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

    
849
    cbp_a = (h->left_cbp>>4)&0x03;
850
    cbp_b = (h-> top_cbp>>4)&0x03;
851

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

    
858
    ctx = 4;
859
    if( cbp_a == 2 ) ctx++;
860
    if( cbp_b == 2 ) ctx += 2;
861
    return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
862
}
863

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

    
890
static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
891
    int refa = h->ref_cache[list][scan8[n] - 1];
892
    int refb = h->ref_cache[list][scan8[n] - 8];
893
    int ref  = 0;
894
    int ctx  = 0;
895

    
896
    if( h->slice_type_nos == FF_B_TYPE) {
897
        if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
898
            ctx++;
899
        if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
900
            ctx += 2;
901
    } else {
902
        if( refa > 0 )
903
            ctx++;
904
        if( refb > 0 )
905
            ctx += 2;
906
    }
907

    
908
    while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
909
        ref++;
910
        ctx = (ctx>>2)+4;
911
        if(ref >= 32 /*h->ref_list[list]*/){
912
            return -1;
913
        }
914
    }
915
    return ref;
916
}
917

    
918
static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
919
    int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
920
               abs( h->mvd_cache[list][scan8[n] - 8][l] );
921
    int ctxbase = (l == 0) ? 40 : 47;
922
    int mvd;
923
    int ctx = (amvd>2) + (amvd>32);
924

    
925
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
926
        return 0;
927

    
928
    mvd= 1;
929
    ctx= 3;
930
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
931
        mvd++;
932
        if( ctx < 6 )
933
            ctx++;
934
    }
935

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

    
954
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
955
    int nza, nzb;
956
    int ctx = 0;
957

    
958
    if( is_dc ) {
959
        if( cat == 0 ) {
960
            nza = h->left_cbp&0x100;
961
            nzb = h-> top_cbp&0x100;
962
        } else {
963
            nza = (h->left_cbp>>(6+idx))&0x01;
964
            nzb = (h-> top_cbp>>(6+idx))&0x01;
965
        }
966
    } else {
967
        assert(cat == 1 || cat == 2 || cat == 4);
968
        nza = h->non_zero_count_cache[scan8[idx] - 1];
969
        nzb = h->non_zero_count_cache[scan8[idx] - 8];
970
    }
971

    
972
    if( nza > 0 )
973
        ctx++;
974

    
975
    if( nzb > 0 )
976
        ctx += 2;
977

    
978
    return ctx + 4 * cat;
979
}
980

    
981
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
982
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
983
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
984
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
985
    5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
986
};
987

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

    
1023
    int index[64];
1024

    
1025
    int av_unused last;
1026
    int coeff_count = 0;
1027
    int node_ctx = 0;
1028

    
1029
    uint8_t *significant_coeff_ctx_base;
1030
    uint8_t *last_coeff_ctx_base;
1031
    uint8_t *abs_level_m1_ctx_base;
1032

    
1033
#if !ARCH_X86
1034
#define CABAC_ON_STACK
1035
#endif
1036
#ifdef CABAC_ON_STACK
1037
#define CC &cc
1038
    CABACContext cc;
1039
    cc.range     = h->cabac.range;
1040
    cc.low       = h->cabac.low;
1041
    cc.bytestream= h->cabac.bytestream;
1042
#else
1043
#define CC &h->cabac
1044
#endif
1045

    
1046

    
1047
    /* cat: 0-> DC 16x16  n = 0
1048
     *      1-> AC 16x16  n = luma4x4idx
1049
     *      2-> Luma4x4   n = luma4x4idx
1050
     *      3-> DC Chroma n = iCbCr
1051
     *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1052
     *      5-> Luma8x8   n = 4 * luma8x8idx
1053
     */
1054

    
1055
    /* read coded block flag */
1056
    if( is_dc || cat != 5 ) {
1057
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1058
            if( !is_dc )
1059
                h->non_zero_count_cache[scan8[n]] = 0;
1060

    
1061
#ifdef CABAC_ON_STACK
1062
            h->cabac.range     = cc.range     ;
1063
            h->cabac.low       = cc.low       ;
1064
            h->cabac.bytestream= cc.bytestream;
1065
#endif
1066
            return;
1067
        }
1068
    }
1069

    
1070
    significant_coeff_ctx_base = h->cabac_state
1071
        + significant_coeff_flag_offset[MB_FIELD][cat];
1072
    last_coeff_ctx_base = h->cabac_state
1073
        + last_coeff_flag_offset[MB_FIELD][cat];
1074
    abs_level_m1_ctx_base = h->cabac_state
1075
        + coeff_abs_level_m1_offset[cat];
1076

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

    
1106
    if( is_dc ) {
1107
        if( cat == 0 )
1108
            h->cbp_table[h->mb_xy] |= 0x100;
1109
        else
1110
            h->cbp_table[h->mb_xy] |= 0x40 << n;
1111
    } else {
1112
        if( cat == 5 )
1113
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1114
        else {
1115
            assert( cat == 1 || cat == 2 || cat == 4 );
1116
            h->non_zero_count_cache[scan8[n]] = coeff_count;
1117
        }
1118
    }
1119

    
1120
    do {
1121
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1122

    
1123
        int j= scantable[index[--coeff_count]];
1124

    
1125
        if( get_cabac( CC, ctx ) == 0 ) {
1126
            node_ctx = coeff_abs_level_transition[0][node_ctx];
1127
            if( is_dc ) {
1128
                block[j] = get_cabac_bypass_sign( CC, -1);
1129
            }else{
1130
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1131
            }
1132
        } else {
1133
            int coeff_abs = 2;
1134
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1135
            node_ctx = coeff_abs_level_transition[1][node_ctx];
1136

    
1137
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1138
                coeff_abs++;
1139
            }
1140

    
1141
            if( coeff_abs >= 15 ) {
1142
                int j = 0;
1143
                while( get_cabac_bypass( CC ) ) {
1144
                    j++;
1145
                }
1146

    
1147
                coeff_abs=1;
1148
                while( j-- ) {
1149
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
1150
                }
1151
                coeff_abs+= 14;
1152
            }
1153

    
1154
            if( is_dc ) {
1155
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1156
            }else{
1157
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1158
            }
1159
        }
1160
    } while( coeff_count );
1161
#ifdef CABAC_ON_STACK
1162
            h->cabac.range     = cc.range     ;
1163
            h->cabac.low       = cc.low       ;
1164
            h->cabac.bytestream= cc.bytestream;
1165
#endif
1166

    
1167
}
1168

    
1169
#if !CONFIG_SMALL
1170
static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1171
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1172
}
1173

    
1174
static void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1175
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1176
}
1177
#endif
1178

    
1179
static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1180
#if CONFIG_SMALL
1181
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1182
#else
1183
    if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1184
    else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1185
#endif
1186
}
1187

    
1188
static inline void compute_mb_neighbors(H264Context *h)
1189
{
1190
    MpegEncContext * const s = &h->s;
1191
    const int mb_xy  = h->mb_xy;
1192
    h->top_mb_xy     = mb_xy - s->mb_stride;
1193
    h->left_mb_xy[0] = mb_xy - 1;
1194
    if(FRAME_MBAFF){
1195
        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
1196
        const int top_pair_xy      = pair_xy     - s->mb_stride;
1197
        const int top_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1198
        const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1199
        const int curr_mb_field_flag = MB_FIELD;
1200
        const int bottom = (s->mb_y & 1);
1201

    
1202
        if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1203
            h->top_mb_xy -= s->mb_stride;
1204
        }
1205
        if (!left_mb_field_flag == curr_mb_field_flag) {
1206
            h->left_mb_xy[0] = pair_xy - 1;
1207
        }
1208
    } else if (FIELD_PICTURE) {
1209
        h->top_mb_xy -= s->mb_stride;
1210
    }
1211
    return;
1212
}
1213

    
1214
/**
1215
 * decodes a macroblock
1216
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1217
 */
1218
int ff_h264_decode_mb_cabac(H264Context *h) {
1219
    MpegEncContext * const s = &h->s;
1220
    int mb_xy;
1221
    int mb_type, partition_count, cbp = 0;
1222
    int dct8x8_allowed= h->pps.transform_8x8_mode;
1223

    
1224
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1225

    
1226
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1227
    if( h->slice_type_nos != FF_I_TYPE ) {
1228
        int skip;
1229
        /* a skipped mb needs the aff flag from the following mb */
1230
        if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1231
            predict_field_decoding_flag(h);
1232
        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1233
            skip = h->next_mb_skipped;
1234
        else
1235
            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1236
        /* read skip flags */
1237
        if( skip ) {
1238
            if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1239
                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1240
                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1241
                if(!h->next_mb_skipped)
1242
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1243
            }
1244

    
1245
            decode_mb_skip(h);
1246

    
1247
            h->cbp_table[mb_xy] = 0;
1248
            h->chroma_pred_mode_table[mb_xy] = 0;
1249
            h->last_qscale_diff = 0;
1250

    
1251
            return 0;
1252

    
1253
        }
1254
    }
1255
    if(FRAME_MBAFF){
1256
        if( (s->mb_y&1) == 0 )
1257
            h->mb_mbaff =
1258
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1259
    }
1260

    
1261
    h->prev_mb_skipped = 0;
1262

    
1263
    compute_mb_neighbors(h);
1264

    
1265
    if( h->slice_type_nos == FF_B_TYPE ) {
1266
        const int mba_xy = h->left_mb_xy[0];
1267
        const int mbb_xy = h->top_mb_xy;
1268
        int ctx = 0;
1269
        assert(h->slice_type_nos == FF_B_TYPE);
1270

    
1271
        if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
1272
            ctx++;
1273
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
1274
            ctx++;
1275

    
1276
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
1277
            mb_type= 0; /* B_Direct_16x16 */
1278
        }else if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
1279
            mb_type= 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
1280
        }else{
1281
            int bits;
1282
            bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
1283
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
1284
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
1285
            bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1286
            if( bits < 8 ){
1287
                mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
1288
            }else if( bits == 13 ){
1289
                mb_type= decode_cabac_intra_mb_type(h, 32, 0);
1290
                goto decode_intra_mb;
1291
            }else if( bits == 14 ){
1292
                mb_type= 11; /* B_L1_L0_8x16 */
1293
            }else if( bits == 15 ){
1294
                mb_type= 22; /* B_8x8 */
1295
            }else{
1296
                bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
1297
                mb_type= bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
1298
            }
1299
        }
1300
            partition_count= b_mb_type_info[mb_type].partition_count;
1301
            mb_type=         b_mb_type_info[mb_type].type;
1302
    } else if( h->slice_type_nos == FF_P_TYPE ) {
1303
        if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1304
            /* P-type */
1305
            if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1306
                /* P_L0_D16x16, P_8x8 */
1307
                mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1308
            } else {
1309
                /* P_L0_D8x16, P_L0_D16x8 */
1310
                mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1311
            }
1312
            partition_count= p_mb_type_info[mb_type].partition_count;
1313
            mb_type=         p_mb_type_info[mb_type].type;
1314
        } else {
1315
            mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1316
            goto decode_intra_mb;
1317
        }
1318
    } else {
1319
        mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1320
        if(h->slice_type == FF_SI_TYPE && mb_type)
1321
            mb_type--;
1322
        assert(h->slice_type_nos == FF_I_TYPE);
1323
decode_intra_mb:
1324
        partition_count = 0;
1325
        cbp= i_mb_type_info[mb_type].cbp;
1326
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1327
        mb_type= i_mb_type_info[mb_type].type;
1328
    }
1329
    if(MB_FIELD)
1330
        mb_type |= MB_TYPE_INTERLACED;
1331

    
1332
    h->slice_table[ mb_xy ]= h->slice_num;
1333

    
1334
    if(IS_INTRA_PCM(mb_type)) {
1335
        const uint8_t *ptr;
1336

    
1337
        // We assume these blocks are very rare so we do not optimize it.
1338
        // FIXME The two following lines get the bitstream position in the cabac
1339
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
1340
        ptr= h->cabac.bytestream;
1341
        if(h->cabac.low&0x1) ptr--;
1342
        if(CABAC_BITS==16){
1343
            if(h->cabac.low&0x1FF) ptr--;
1344
        }
1345

    
1346
        // The pixels are stored in the same order as levels in h->mb array.
1347
        memcpy(h->mb, ptr, 256); ptr+=256;
1348
        if(CHROMA){
1349
            memcpy(h->mb+128, ptr, 128); ptr+=128;
1350
        }
1351

    
1352
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1353

    
1354
        // All blocks are present
1355
        h->cbp_table[mb_xy] = 0x1ef;
1356
        h->chroma_pred_mode_table[mb_xy] = 0;
1357
        // In deblocking, the quantizer is 0
1358
        s->current_picture.qscale_table[mb_xy]= 0;
1359
        // All coeffs are present
1360
        memset(h->non_zero_count[mb_xy], 16, 32);
1361
        s->current_picture.mb_type[mb_xy]= mb_type;
1362
        h->last_qscale_diff = 0;
1363
        return 0;
1364
    }
1365

    
1366
    if(MB_MBAFF){
1367
        h->ref_count[0] <<= 1;
1368
        h->ref_count[1] <<= 1;
1369
    }
1370

    
1371
    fill_decode_caches(h, mb_type);
1372

    
1373
    if( IS_INTRA( mb_type ) ) {
1374
        int i, pred_mode;
1375
        if( IS_INTRA4x4( mb_type ) ) {
1376
            if( dct8x8_allowed && get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] ) ) {
1377
                mb_type |= MB_TYPE_8x8DCT;
1378
                for( i = 0; i < 16; i+=4 ) {
1379
                    int pred = pred_intra_mode( h, i );
1380
                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1381
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1382
                }
1383
            } else {
1384
                for( i = 0; i < 16; i++ ) {
1385
                    int pred = pred_intra_mode( h, i );
1386
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1387

    
1388
                //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1389
                }
1390
            }
1391
            ff_h264_write_back_intra_pred_mode(h);
1392
            if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1393
        } else {
1394
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1395
            if( h->intra16x16_pred_mode < 0 ) return -1;
1396
        }
1397
        if(CHROMA){
1398
            h->chroma_pred_mode_table[mb_xy] =
1399
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1400

    
1401
            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1402
            if( pred_mode < 0 ) return -1;
1403
            h->chroma_pred_mode= pred_mode;
1404
        }
1405
    } else if( partition_count == 4 ) {
1406
        int i, j, sub_partition_count[4], list, ref[2][4];
1407

    
1408
        if( h->slice_type_nos == FF_B_TYPE ) {
1409
            for( i = 0; i < 4; i++ ) {
1410
                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1411
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1412
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1413
            }
1414
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1415
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1416
                ff_h264_pred_direct_motion(h, &mb_type);
1417
                h->ref_cache[0][scan8[4]] =
1418
                h->ref_cache[1][scan8[4]] =
1419
                h->ref_cache[0][scan8[12]] =
1420
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1421
                    for( i = 0; i < 4; i++ )
1422
                        fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, (h->sub_mb_type[i]>>1)&0xFF, 1 );
1423
            }
1424
        } else {
1425
            for( i = 0; i < 4; i++ ) {
1426
                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1427
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1428
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1429
            }
1430
        }
1431

    
1432
        for( list = 0; list < h->list_count; list++ ) {
1433
                for( i = 0; i < 4; i++ ) {
1434
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
1435
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
1436
                        if( h->ref_count[list] > 1 ){
1437
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1438
                            if(ref[list][i] >= (unsigned)h->ref_count[list]){
1439
                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1440
                                return -1;
1441
                            }
1442
                        }else
1443
                            ref[list][i] = 0;
1444
                    } else {
1445
                        ref[list][i] = -1;
1446
                    }
1447
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
1448
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1449
                }
1450
        }
1451

    
1452
        if(dct8x8_allowed)
1453
            dct8x8_allowed = get_dct8x8_allowed(h);
1454

    
1455
        for(list=0; list<h->list_count; list++){
1456
            for(i=0; i<4; i++){
1457
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1458
                if(IS_DIRECT(h->sub_mb_type[i])){
1459
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1460
                    continue;
1461
                }
1462

    
1463
                if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1464
                    const int sub_mb_type= h->sub_mb_type[i];
1465
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1466
                    for(j=0; j<sub_partition_count[i]; j++){
1467
                        int mpx, mpy;
1468
                        int mx, my;
1469
                        const int index= 4*i + block_width*j;
1470
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1471
                        int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1472
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1473

    
1474
                        mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
1475
                        my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
1476
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1477

    
1478
                        if(IS_SUB_8X8(sub_mb_type)){
1479
                            mv_cache[ 1 ][0]=
1480
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1481
                            mv_cache[ 1 ][1]=
1482
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1483

    
1484
                            mvd_cache[ 1 ][0]=
1485
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1486
                            mvd_cache[ 1 ][1]=
1487
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1488
                        }else if(IS_SUB_8X4(sub_mb_type)){
1489
                            mv_cache[ 1 ][0]= mx;
1490
                            mv_cache[ 1 ][1]= my;
1491

    
1492
                            mvd_cache[ 1 ][0]= mx - mpx;
1493
                            mvd_cache[ 1 ][1]= my - mpy;
1494
                        }else if(IS_SUB_4X8(sub_mb_type)){
1495
                            mv_cache[ 8 ][0]= mx;
1496
                            mv_cache[ 8 ][1]= my;
1497

    
1498
                            mvd_cache[ 8 ][0]= mx - mpx;
1499
                            mvd_cache[ 8 ][1]= my - mpy;
1500
                        }
1501
                        mv_cache[ 0 ][0]= mx;
1502
                        mv_cache[ 0 ][1]= my;
1503

    
1504
                        mvd_cache[ 0 ][0]= mx - mpx;
1505
                        mvd_cache[ 0 ][1]= my - mpy;
1506
                    }
1507
                }else{
1508
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1509
                    uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1510
                    p[0] = p[1] = p[8] = p[9] = 0;
1511
                    pd[0]= pd[1]= pd[8]= pd[9]= 0;
1512
                }
1513
            }
1514
        }
1515
    } else if( IS_DIRECT(mb_type) ) {
1516
        ff_h264_pred_direct_motion(h, &mb_type);
1517
        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1518
        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1519
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1520
    } else {
1521
        int list, mx, my, i, mpx, mpy;
1522
        if(IS_16X16(mb_type)){
1523
            for(list=0; list<h->list_count; list++){
1524
                if(IS_DIR(mb_type, 0, list)){
1525
                    int ref;
1526
                    if(h->ref_count[list] > 1){
1527
                        ref= decode_cabac_mb_ref(h, list, 0);
1528
                        if(ref >= (unsigned)h->ref_count[list]){
1529
                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1530
                            return -1;
1531
                        }
1532
                    }else
1533
                        ref=0;
1534
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1535
                }else
1536
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
1537
            }
1538
            for(list=0; list<h->list_count; list++){
1539
                if(IS_DIR(mb_type, 0, list)){
1540
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1541

    
1542
                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1543
                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1544
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1545

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

    
1578
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1579
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1580
                    }else{
1581
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1582
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1583
                    }
1584
                }
1585
            }
1586
        }else{
1587
            assert(IS_8X16(mb_type));
1588
            for(list=0; list<h->list_count; list++){
1589
                    for(i=0; i<2; i++){
1590
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1591
                            int ref;
1592
                            if(h->ref_count[list] > 1){
1593
                                ref= decode_cabac_mb_ref( h, list, 4*i );
1594
                                if(ref >= (unsigned)h->ref_count[list]){
1595
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1596
                                    return -1;
1597
                                }
1598
                            }else
1599
                                ref=0;
1600
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1601
                        }else
1602
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1603
                    }
1604
            }
1605
            for(list=0; list<h->list_count; list++){
1606
                for(i=0; i<2; i++){
1607
                    if(IS_DIR(mb_type, i, list)){
1608
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1609
                        mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1610
                        my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1611

    
1612
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1613
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1614
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1615
                    }else{
1616
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1617
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1618
                    }
1619
                }
1620
            }
1621
        }
1622
    }
1623

    
1624
   if( IS_INTER( mb_type ) ) {
1625
        h->chroma_pred_mode_table[mb_xy] = 0;
1626
        write_back_motion( h, mb_type );
1627
   }
1628

    
1629
    if( !IS_INTRA16x16( mb_type ) ) {
1630
        cbp  = decode_cabac_mb_cbp_luma( h );
1631
        if(CHROMA)
1632
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1633
    }
1634

    
1635
    h->cbp_table[mb_xy] = h->cbp = cbp;
1636

    
1637
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1638
        mb_type |= MB_TYPE_8x8DCT * get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
1639
    }
1640
    s->current_picture.mb_type[mb_xy]= mb_type;
1641

    
1642
    if( cbp || IS_INTRA16x16( mb_type ) ) {
1643
        const uint8_t *scan, *scan8x8, *dc_scan;
1644
        const uint32_t *qmul;
1645

    
1646
        if(IS_INTERLACED(mb_type)){
1647
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1648
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
1649
            dc_scan= luma_dc_field_scan;
1650
        }else{
1651
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1652
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1653
            dc_scan= luma_dc_zigzag_scan;
1654
        }
1655

    
1656
        // decode_cabac_mb_dqp
1657
        if(get_cabac_noinline( &h->cabac, &h->cabac_state[60 + (h->last_qscale_diff != 0)])){
1658
            int val = 1;
1659
            int ctx= 2;
1660

    
1661
            while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
1662
                ctx= 3;
1663
                val++;
1664
                if(val > 102){ //prevent infinite loop
1665
                    av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1666
                    return -1;
1667
                }
1668
            }
1669

    
1670
            if( val&0x01 )
1671
                val=   (val + 1)>>1 ;
1672
            else
1673
                val= -((val + 1)>>1);
1674
            h->last_qscale_diff = val;
1675
            s->qscale += val;
1676
            if(((unsigned)s->qscale) > 51){
1677
                if(s->qscale<0) s->qscale+= 52;
1678
                else            s->qscale-= 52;
1679
            }
1680
            h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1681
            h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1682
        }else
1683
            h->last_qscale_diff=0;
1684

    
1685
        if( IS_INTRA16x16( mb_type ) ) {
1686
            int i;
1687
            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1688
            decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1689

    
1690
            if( cbp&15 ) {
1691
                qmul = h->dequant4_coeff[0][s->qscale];
1692
                for( i = 0; i < 16; i++ ) {
1693
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1694
                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1695
                }
1696
            } else {
1697
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1698
            }
1699
        } else {
1700
            int i8x8, i4x4;
1701
            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1702
                if( cbp & (1<<i8x8) ) {
1703
                    if( IS_8x8DCT(mb_type) ) {
1704
                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1705
                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1706
                    } else {
1707
                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1708
                        for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1709
                            const int index = 4*i8x8 + i4x4;
1710
                            //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1711
//START_TIMER
1712
                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1713
//STOP_TIMER("decode_residual")
1714
                        }
1715
                    }
1716
                } else {
1717
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1718
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1719
                }
1720
            }
1721
        }
1722

    
1723
        if( cbp&0x30 ){
1724
            int c;
1725
            for( c = 0; c < 2; c++ ) {
1726
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1727
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1728
            }
1729
        }
1730

    
1731
        if( cbp&0x20 ) {
1732
            int c, i;
1733
            for( c = 0; c < 2; c++ ) {
1734
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1735
                for( i = 0; i < 4; i++ ) {
1736
                    const int index = 16 + 4 * c + i;
1737
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1738
                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1739
                }
1740
            }
1741
        } else {
1742
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1743
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1744
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1745
        }
1746
    } else {
1747
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1748
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1749
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1750
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1751
        h->last_qscale_diff = 0;
1752
    }
1753

    
1754
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1755
    write_back_non_zero_count(h);
1756

    
1757
    if(MB_MBAFF){
1758
        h->ref_count[0] >>= 1;
1759
        h->ref_count[1] >>= 1;
1760
    }
1761

    
1762
    return 0;
1763
}