Statistics
| Branch: | Revision:

ffmpeg / libavcodec / h264_cabac.c @ 2dc380ca

History | View | Annotate | Download (73 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_type_b( H264Context *h ) {
754
    MpegEncContext * const s = &h->s;
755

    
756
        const int mba_xy = h->left_mb_xy[0];
757
        const int mbb_xy = h->top_mb_xy;
758
        int ctx = 0;
759
        int bits;
760
        assert(h->slice_type_nos == FF_B_TYPE);
761

    
762
        if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
763
            ctx++;
764
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
765
            ctx++;
766

    
767
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
768
            return 0; /* B_Direct_16x16 */
769

    
770
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
771
            return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
772
        }
773

    
774
        bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
775
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
776
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
777
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
778
        if( bits < 8 )
779
            return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
780
        else if( bits == 13 ) {
781
            return decode_cabac_intra_mb_type(h, 32, 0) + 23;
782
        } else if( bits == 14 )
783
            return 11; /* B_L1_L0_8x16 */
784
        else if( bits == 15 )
785
            return 22; /* B_8x8 */
786

    
787
        bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
788
        return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
789
}
790

    
791
static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
792
    MpegEncContext * const s = &h->s;
793
    int mba_xy, mbb_xy;
794
    int ctx = 0;
795

    
796
    if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
797
        int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
798
        mba_xy = mb_xy - 1;
799
        if( (mb_y&1)
800
            && h->slice_table[mba_xy] == h->slice_num
801
            && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
802
            mba_xy += s->mb_stride;
803
        if( MB_FIELD ){
804
            mbb_xy = mb_xy - s->mb_stride;
805
            if( !(mb_y&1)
806
                && h->slice_table[mbb_xy] == h->slice_num
807
                && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
808
                mbb_xy -= s->mb_stride;
809
        }else
810
            mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
811
    }else{
812
        int mb_xy = h->mb_xy;
813
        mba_xy = mb_xy - 1;
814
        mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
815
    }
816

    
817
    if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
818
        ctx++;
819
    if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
820
        ctx++;
821

    
822
    if( h->slice_type_nos == FF_B_TYPE )
823
        ctx += 13;
824
    return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
825
}
826

    
827
static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
828
    int mode = 0;
829

    
830
    if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
831
        return pred_mode;
832

    
833
    mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
834
    mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
835
    mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
836

    
837
    if( mode >= pred_mode )
838
        return mode + 1;
839
    else
840
        return mode;
841
}
842

    
843
static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
844
    const int mba_xy = h->left_mb_xy[0];
845
    const int mbb_xy = h->top_mb_xy;
846

    
847
    int ctx = 0;
848

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

    
853
    if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
854
        ctx++;
855

    
856
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
857
        return 0;
858

    
859
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
860
        return 1;
861
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
862
        return 2;
863
    else
864
        return 3;
865
}
866

    
867
static int decode_cabac_mb_cbp_luma( H264Context *h) {
868
    int cbp_b, cbp_a, ctx, cbp = 0;
869

    
870
    cbp_a = h->left_cbp;
871
    cbp_b = h->top_cbp;
872

    
873
    ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
874
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
875
    ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
876
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
877
    ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
878
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
879
    ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
880
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
881
    return cbp;
882
}
883
static int decode_cabac_mb_cbp_chroma( H264Context *h) {
884
    int ctx;
885
    int cbp_a, cbp_b;
886

    
887
    cbp_a = (h->left_cbp>>4)&0x03;
888
    cbp_b = (h-> top_cbp>>4)&0x03;
889

    
890
    ctx = 0;
891
    if( cbp_a > 0 ) ctx++;
892
    if( cbp_b > 0 ) ctx += 2;
893
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
894
        return 0;
895

    
896
    ctx = 4;
897
    if( cbp_a == 2 ) ctx++;
898
    if( cbp_b == 2 ) ctx += 2;
899
    return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
900
}
901
static int decode_cabac_mb_dqp( H264Context *h) {
902
    int   ctx= h->last_qscale_diff != 0;
903
    int   val = 0;
904

    
905
    while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
906
        ctx= 2+(ctx>>1);
907
        val++;
908
        if(val > 102) //prevent infinite loop
909
            return INT_MIN;
910
    }
911

    
912
    if( val&0x01 )
913
        return   (val + 1)>>1 ;
914
    else
915
        return -((val + 1)>>1);
916
}
917
static int decode_cabac_p_mb_sub_type( H264Context *h ) {
918
    if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
919
        return 0;   /* 8x8 */
920
    if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
921
        return 1;   /* 8x4 */
922
    if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
923
        return 2;   /* 4x8 */
924
    return 3;       /* 4x4 */
925
}
926
static int decode_cabac_b_mb_sub_type( H264Context *h ) {
927
    int type;
928
    if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
929
        return 0;   /* B_Direct_8x8 */
930
    if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
931
        return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
932
    type = 3;
933
    if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
934
        if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
935
            return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
936
        type += 4;
937
    }
938
    type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
939
    type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
940
    return type;
941
}
942

    
943
static inline int decode_cabac_mb_transform_size( H264Context *h ) {
944
    return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
945
}
946

    
947
static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
948
    int refa = h->ref_cache[list][scan8[n] - 1];
949
    int refb = h->ref_cache[list][scan8[n] - 8];
950
    int ref  = 0;
951
    int ctx  = 0;
952

    
953
    if( h->slice_type_nos == FF_B_TYPE) {
954
        if( refa > 0 && !(h->direct_cache[scan8[n] - 1]&(MB_TYPE_DIRECT2>>1)) )
955
            ctx++;
956
        if( refb > 0 && !(h->direct_cache[scan8[n] - 8]&(MB_TYPE_DIRECT2>>1)) )
957
            ctx += 2;
958
    } else {
959
        if( refa > 0 )
960
            ctx++;
961
        if( refb > 0 )
962
            ctx += 2;
963
    }
964

    
965
    while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
966
        ref++;
967
        ctx = (ctx>>2)+4;
968
        if(ref >= 32 /*h->ref_list[list]*/){
969
            return -1;
970
        }
971
    }
972
    return ref;
973
}
974

    
975
static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
976
    int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
977
               abs( h->mvd_cache[list][scan8[n] - 8][l] );
978
    int ctxbase = (l == 0) ? 40 : 47;
979
    int mvd;
980
    int ctx = (amvd>2) + (amvd>32);
981

    
982
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
983
        return 0;
984

    
985
    mvd= 1;
986
    ctx= 3;
987
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
988
        mvd++;
989
        if( ctx < 6 )
990
            ctx++;
991
    }
992

    
993
    if( mvd >= 9 ) {
994
        int k = 3;
995
        while( get_cabac_bypass( &h->cabac ) ) {
996
            mvd += 1 << k;
997
            k++;
998
            if(k>24){
999
                av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
1000
                return INT_MIN;
1001
            }
1002
        }
1003
        while( k-- ) {
1004
            if( get_cabac_bypass( &h->cabac ) )
1005
                mvd += 1 << k;
1006
        }
1007
    }
1008
    return get_cabac_bypass_sign( &h->cabac, -mvd );
1009
}
1010

    
1011
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
1012
    int nza, nzb;
1013
    int ctx = 0;
1014

    
1015
    if( is_dc ) {
1016
        if( cat == 0 ) {
1017
            nza = h->left_cbp&0x100;
1018
            nzb = h-> top_cbp&0x100;
1019
        } else {
1020
            nza = (h->left_cbp>>(6+idx))&0x01;
1021
            nzb = (h-> top_cbp>>(6+idx))&0x01;
1022
        }
1023
    } else {
1024
        assert(cat == 1 || cat == 2 || cat == 4);
1025
        nza = h->non_zero_count_cache[scan8[idx] - 1];
1026
        nzb = h->non_zero_count_cache[scan8[idx] - 8];
1027
    }
1028

    
1029
    if( nza > 0 )
1030
        ctx++;
1031

    
1032
    if( nzb > 0 )
1033
        ctx += 2;
1034

    
1035
    return ctx + 4 * cat;
1036
}
1037

    
1038
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8)[63] = {
1039
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1040
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1041
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
1042
    5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
1043
};
1044

    
1045
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 ) {
1046
    static const int significant_coeff_flag_offset[2][6] = {
1047
      { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
1048
      { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
1049
    };
1050
    static const int last_coeff_flag_offset[2][6] = {
1051
      { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
1052
      { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
1053
    };
1054
    static const int coeff_abs_level_m1_offset[6] = {
1055
        227+0, 227+10, 227+20, 227+30, 227+39, 426
1056
    };
1057
    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
1058
      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
1059
        4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
1060
        7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
1061
       12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
1062
      { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
1063
        6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
1064
        9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
1065
        9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
1066
    };
1067
    /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
1068
     * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
1069
     * map node ctx => cabac ctx for level=1 */
1070
    static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
1071
    /* map node ctx => cabac ctx for level>1 */
1072
    static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
1073
    static const uint8_t coeff_abs_level_transition[2][8] = {
1074
    /* update node ctx after decoding a level=1 */
1075
        { 1, 2, 3, 3, 4, 5, 6, 7 },
1076
    /* update node ctx after decoding a level>1 */
1077
        { 4, 4, 4, 4, 5, 6, 7, 7 }
1078
    };
1079

    
1080
    int index[64];
1081

    
1082
    int av_unused last;
1083
    int coeff_count = 0;
1084
    int node_ctx = 0;
1085

    
1086
    uint8_t *significant_coeff_ctx_base;
1087
    uint8_t *last_coeff_ctx_base;
1088
    uint8_t *abs_level_m1_ctx_base;
1089

    
1090
#if !ARCH_X86
1091
#define CABAC_ON_STACK
1092
#endif
1093
#ifdef CABAC_ON_STACK
1094
#define CC &cc
1095
    CABACContext cc;
1096
    cc.range     = h->cabac.range;
1097
    cc.low       = h->cabac.low;
1098
    cc.bytestream= h->cabac.bytestream;
1099
#else
1100
#define CC &h->cabac
1101
#endif
1102

    
1103

    
1104
    /* cat: 0-> DC 16x16  n = 0
1105
     *      1-> AC 16x16  n = luma4x4idx
1106
     *      2-> Luma4x4   n = luma4x4idx
1107
     *      3-> DC Chroma n = iCbCr
1108
     *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
1109
     *      5-> Luma8x8   n = 4 * luma8x8idx
1110
     */
1111

    
1112
    /* read coded block flag */
1113
    if( is_dc || cat != 5 ) {
1114
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
1115
            if( !is_dc )
1116
                h->non_zero_count_cache[scan8[n]] = 0;
1117

    
1118
#ifdef CABAC_ON_STACK
1119
            h->cabac.range     = cc.range     ;
1120
            h->cabac.low       = cc.low       ;
1121
            h->cabac.bytestream= cc.bytestream;
1122
#endif
1123
            return;
1124
        }
1125
    }
1126

    
1127
    significant_coeff_ctx_base = h->cabac_state
1128
        + significant_coeff_flag_offset[MB_FIELD][cat];
1129
    last_coeff_ctx_base = h->cabac_state
1130
        + last_coeff_flag_offset[MB_FIELD][cat];
1131
    abs_level_m1_ctx_base = h->cabac_state
1132
        + coeff_abs_level_m1_offset[cat];
1133

    
1134
    if( !is_dc && cat == 5 ) {
1135
#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
1136
        for(last= 0; last < coefs; last++) { \
1137
            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
1138
            if( get_cabac( CC, sig_ctx )) { \
1139
                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
1140
                index[coeff_count++] = last; \
1141
                if( get_cabac( CC, last_ctx ) ) { \
1142
                    last= max_coeff; \
1143
                    break; \
1144
                } \
1145
            } \
1146
        }\
1147
        if( last == max_coeff -1 ) {\
1148
            index[coeff_count++] = last;\
1149
        }
1150
        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
1151
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE && !defined(BROKEN_RELOCATIONS)
1152
        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
1153
    } else {
1154
        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
1155
#else
1156
        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
1157
    } else {
1158
        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
1159
#endif
1160
    }
1161
    assert(coeff_count > 0);
1162

    
1163
    if( is_dc ) {
1164
        if( cat == 0 )
1165
            h->cbp_table[h->mb_xy] |= 0x100;
1166
        else
1167
            h->cbp_table[h->mb_xy] |= 0x40 << n;
1168
    } else {
1169
        if( cat == 5 )
1170
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
1171
        else {
1172
            assert( cat == 1 || cat == 2 || cat == 4 );
1173
            h->non_zero_count_cache[scan8[n]] = coeff_count;
1174
        }
1175
    }
1176

    
1177
    do {
1178
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;
1179

    
1180
        int j= scantable[index[--coeff_count]];
1181

    
1182
        if( get_cabac( CC, ctx ) == 0 ) {
1183
            node_ctx = coeff_abs_level_transition[0][node_ctx];
1184
            if( is_dc ) {
1185
                block[j] = get_cabac_bypass_sign( CC, -1);
1186
            }else{
1187
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
1188
            }
1189
        } else {
1190
            int coeff_abs = 2;
1191
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
1192
            node_ctx = coeff_abs_level_transition[1][node_ctx];
1193

    
1194
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
1195
                coeff_abs++;
1196
            }
1197

    
1198
            if( coeff_abs >= 15 ) {
1199
                int j = 0;
1200
                while( get_cabac_bypass( CC ) ) {
1201
                    j++;
1202
                }
1203

    
1204
                coeff_abs=1;
1205
                while( j-- ) {
1206
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
1207
                }
1208
                coeff_abs+= 14;
1209
            }
1210

    
1211
            if( is_dc ) {
1212
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
1213
            }else{
1214
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
1215
            }
1216
        }
1217
    } while( coeff_count );
1218
#ifdef CABAC_ON_STACK
1219
            h->cabac.range     = cc.range     ;
1220
            h->cabac.low       = cc.low       ;
1221
            h->cabac.bytestream= cc.bytestream;
1222
#endif
1223

    
1224
}
1225

    
1226
#if !CONFIG_SMALL
1227
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 ) {
1228
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
1229
}
1230

    
1231
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 ) {
1232
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
1233
}
1234
#endif
1235

    
1236
static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
1237
#if CONFIG_SMALL
1238
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
1239
#else
1240
    if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
1241
    else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
1242
#endif
1243
}
1244

    
1245
static inline void compute_mb_neighbors(H264Context *h)
1246
{
1247
    MpegEncContext * const s = &h->s;
1248
    const int mb_xy  = h->mb_xy;
1249
    h->top_mb_xy     = mb_xy - s->mb_stride;
1250
    h->left_mb_xy[0] = mb_xy - 1;
1251
    if(FRAME_MBAFF){
1252
        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
1253
        const int top_pair_xy      = pair_xy     - s->mb_stride;
1254
        const int top_mb_field_flag  = IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
1255
        const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
1256
        const int curr_mb_field_flag = MB_FIELD;
1257
        const int bottom = (s->mb_y & 1);
1258

    
1259
        if (curr_mb_field_flag && (bottom || top_mb_field_flag)){
1260
            h->top_mb_xy -= s->mb_stride;
1261
        }
1262
        if (!left_mb_field_flag == curr_mb_field_flag) {
1263
            h->left_mb_xy[0] = pair_xy - 1;
1264
        }
1265
    } else if (FIELD_PICTURE) {
1266
        h->top_mb_xy -= s->mb_stride;
1267
    }
1268
    return;
1269
}
1270

    
1271
/**
1272
 * decodes a macroblock
1273
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
1274
 */
1275
int ff_h264_decode_mb_cabac(H264Context *h) {
1276
    MpegEncContext * const s = &h->s;
1277
    int mb_xy;
1278
    int mb_type, partition_count, cbp = 0;
1279
    int dct8x8_allowed= h->pps.transform_8x8_mode;
1280

    
1281
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1282

    
1283
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
1284
    if( h->slice_type_nos != FF_I_TYPE ) {
1285
        int skip;
1286
        /* a skipped mb needs the aff flag from the following mb */
1287
        if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
1288
            predict_field_decoding_flag(h);
1289
        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
1290
            skip = h->next_mb_skipped;
1291
        else
1292
            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
1293
        /* read skip flags */
1294
        if( skip ) {
1295
            if( FRAME_MBAFF && (s->mb_y&1)==0 ){
1296
                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
1297
                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
1298
                if(!h->next_mb_skipped)
1299
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1300
            }
1301

    
1302
            decode_mb_skip(h);
1303

    
1304
            h->cbp_table[mb_xy] = 0;
1305
            h->chroma_pred_mode_table[mb_xy] = 0;
1306
            h->last_qscale_diff = 0;
1307

    
1308
            return 0;
1309

    
1310
        }
1311
    }
1312
    if(FRAME_MBAFF){
1313
        if( (s->mb_y&1) == 0 )
1314
            h->mb_mbaff =
1315
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
1316
    }
1317

    
1318
    h->prev_mb_skipped = 0;
1319

    
1320
    compute_mb_neighbors(h);
1321

    
1322
    if( h->slice_type_nos == FF_B_TYPE ) {
1323
        mb_type = decode_cabac_mb_type_b( h );
1324
        if( mb_type < 23 ){
1325
            partition_count= b_mb_type_info[mb_type].partition_count;
1326
            mb_type=         b_mb_type_info[mb_type].type;
1327
        }else{
1328
            mb_type -= 23;
1329
            goto decode_intra_mb;
1330
        }
1331
    } else if( h->slice_type_nos == FF_P_TYPE ) {
1332
        if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
1333
            /* P-type */
1334
            if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
1335
                /* P_L0_D16x16, P_8x8 */
1336
                mb_type= 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
1337
            } else {
1338
                /* P_L0_D8x16, P_L0_D16x8 */
1339
                mb_type= 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
1340
            }
1341
            partition_count= p_mb_type_info[mb_type].partition_count;
1342
            mb_type=         p_mb_type_info[mb_type].type;
1343
        } else {
1344
            mb_type= decode_cabac_intra_mb_type(h, 17, 0);
1345
            goto decode_intra_mb;
1346
        }
1347
    } else {
1348
        mb_type= decode_cabac_intra_mb_type(h, 3, 1);
1349
        if(h->slice_type == FF_SI_TYPE && mb_type)
1350
            mb_type--;
1351
        assert(h->slice_type_nos == FF_I_TYPE);
1352
decode_intra_mb:
1353
        partition_count = 0;
1354
        cbp= i_mb_type_info[mb_type].cbp;
1355
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
1356
        mb_type= i_mb_type_info[mb_type].type;
1357
    }
1358
    if(MB_FIELD)
1359
        mb_type |= MB_TYPE_INTERLACED;
1360

    
1361
    h->slice_table[ mb_xy ]= h->slice_num;
1362

    
1363
    if(IS_INTRA_PCM(mb_type)) {
1364
        const uint8_t *ptr;
1365

    
1366
        // We assume these blocks are very rare so we do not optimize it.
1367
        // FIXME The two following lines get the bitstream position in the cabac
1368
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
1369
        ptr= h->cabac.bytestream;
1370
        if(h->cabac.low&0x1) ptr--;
1371
        if(CABAC_BITS==16){
1372
            if(h->cabac.low&0x1FF) ptr--;
1373
        }
1374

    
1375
        // The pixels are stored in the same order as levels in h->mb array.
1376
        memcpy(h->mb, ptr, 256); ptr+=256;
1377
        if(CHROMA){
1378
            memcpy(h->mb+128, ptr, 128); ptr+=128;
1379
        }
1380

    
1381
        ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
1382

    
1383
        // All blocks are present
1384
        h->cbp_table[mb_xy] = 0x1ef;
1385
        h->chroma_pred_mode_table[mb_xy] = 0;
1386
        // In deblocking, the quantizer is 0
1387
        s->current_picture.qscale_table[mb_xy]= 0;
1388
        // All coeffs are present
1389
        memset(h->non_zero_count[mb_xy], 16, 32);
1390
        s->current_picture.mb_type[mb_xy]= mb_type;
1391
        h->last_qscale_diff = 0;
1392
        return 0;
1393
    }
1394

    
1395
    if(MB_MBAFF){
1396
        h->ref_count[0] <<= 1;
1397
        h->ref_count[1] <<= 1;
1398
    }
1399

    
1400
    fill_decode_caches(h, mb_type);
1401

    
1402
    if( IS_INTRA( mb_type ) ) {
1403
        int i, pred_mode;
1404
        if( IS_INTRA4x4( mb_type ) ) {
1405
            if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
1406
                mb_type |= MB_TYPE_8x8DCT;
1407
                for( i = 0; i < 16; i+=4 ) {
1408
                    int pred = pred_intra_mode( h, i );
1409
                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1410
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
1411
                }
1412
            } else {
1413
                for( i = 0; i < 16; i++ ) {
1414
                    int pred = pred_intra_mode( h, i );
1415
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
1416

    
1417
                //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
1418
                }
1419
            }
1420
            ff_h264_write_back_intra_pred_mode(h);
1421
            if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
1422
        } else {
1423
            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
1424
            if( h->intra16x16_pred_mode < 0 ) return -1;
1425
        }
1426
        if(CHROMA){
1427
            h->chroma_pred_mode_table[mb_xy] =
1428
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
1429

    
1430
            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
1431
            if( pred_mode < 0 ) return -1;
1432
            h->chroma_pred_mode= pred_mode;
1433
        }
1434
    } else if( partition_count == 4 ) {
1435
        int i, j, sub_partition_count[4], list, ref[2][4];
1436

    
1437
        if( h->slice_type_nos == FF_B_TYPE ) {
1438
            for( i = 0; i < 4; i++ ) {
1439
                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
1440
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1441
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1442
            }
1443
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
1444
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
1445
                ff_h264_pred_direct_motion(h, &mb_type);
1446
                h->ref_cache[0][scan8[4]] =
1447
                h->ref_cache[1][scan8[4]] =
1448
                h->ref_cache[0][scan8[12]] =
1449
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
1450
                if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
1451
                    for( i = 0; i < 4; i++ )
1452
                        if( IS_DIRECT(h->sub_mb_type[i]) )
1453
                            fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, MB_TYPE_DIRECT2>>1, 1 );
1454
                }
1455
            }
1456
        } else {
1457
            for( i = 0; i < 4; i++ ) {
1458
                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
1459
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
1460
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
1461
            }
1462
        }
1463

    
1464
        for( list = 0; list < h->list_count; list++ ) {
1465
                for( i = 0; i < 4; i++ ) {
1466
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
1467
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
1468
                        if( h->ref_count[list] > 1 ){
1469
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
1470
                            if(ref[list][i] >= (unsigned)h->ref_count[list]){
1471
                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
1472
                                return -1;
1473
                            }
1474
                        }else
1475
                            ref[list][i] = 0;
1476
                    } else {
1477
                        ref[list][i] = -1;
1478
                    }
1479
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
1480
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
1481
                }
1482
        }
1483

    
1484
        if(dct8x8_allowed)
1485
            dct8x8_allowed = get_dct8x8_allowed(h);
1486

    
1487
        for(list=0; list<h->list_count; list++){
1488
            for(i=0; i<4; i++){
1489
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
1490
                if(IS_DIRECT(h->sub_mb_type[i])){
1491
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
1492
                    continue;
1493
                }
1494

    
1495
                if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
1496
                    const int sub_mb_type= h->sub_mb_type[i];
1497
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
1498
                    for(j=0; j<sub_partition_count[i]; j++){
1499
                        int mpx, mpy;
1500
                        int mx, my;
1501
                        const int index= 4*i + block_width*j;
1502
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
1503
                        int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
1504
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
1505

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

    
1510
                        if(IS_SUB_8X8(sub_mb_type)){
1511
                            mv_cache[ 1 ][0]=
1512
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
1513
                            mv_cache[ 1 ][1]=
1514
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
1515

    
1516
                            mvd_cache[ 1 ][0]=
1517
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
1518
                            mvd_cache[ 1 ][1]=
1519
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
1520
                        }else if(IS_SUB_8X4(sub_mb_type)){
1521
                            mv_cache[ 1 ][0]= mx;
1522
                            mv_cache[ 1 ][1]= my;
1523

    
1524
                            mvd_cache[ 1 ][0]= mx - mpx;
1525
                            mvd_cache[ 1 ][1]= my - mpy;
1526
                        }else if(IS_SUB_4X8(sub_mb_type)){
1527
                            mv_cache[ 8 ][0]= mx;
1528
                            mv_cache[ 8 ][1]= my;
1529

    
1530
                            mvd_cache[ 8 ][0]= mx - mpx;
1531
                            mvd_cache[ 8 ][1]= my - mpy;
1532
                        }
1533
                        mv_cache[ 0 ][0]= mx;
1534
                        mv_cache[ 0 ][1]= my;
1535

    
1536
                        mvd_cache[ 0 ][0]= mx - mpx;
1537
                        mvd_cache[ 0 ][1]= my - mpy;
1538
                    }
1539
                }else{
1540
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
1541
                    uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
1542
                    p[0] = p[1] = p[8] = p[9] = 0;
1543
                    pd[0]= pd[1]= pd[8]= pd[9]= 0;
1544
                }
1545
            }
1546
        }
1547
    } else if( IS_DIRECT(mb_type) ) {
1548
        ff_h264_pred_direct_motion(h, &mb_type);
1549
        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1550
        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1551
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
1552
    } else {
1553
        int list, mx, my, i, mpx, mpy;
1554
        if(IS_16X16(mb_type)){
1555
            for(list=0; list<h->list_count; list++){
1556
                if(IS_DIR(mb_type, 0, list)){
1557
                    int ref;
1558
                    if(h->ref_count[list] > 1){
1559
                        ref= decode_cabac_mb_ref(h, list, 0);
1560
                        if(ref >= (unsigned)h->ref_count[list]){
1561
                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1562
                            return -1;
1563
                        }
1564
                    }else
1565
                        ref=0;
1566
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
1567
                }else
1568
                    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
1569
            }
1570
            for(list=0; list<h->list_count; list++){
1571
                if(IS_DIR(mb_type, 0, list)){
1572
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
1573

    
1574
                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
1575
                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
1576
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1577

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

    
1610
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
1611
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
1612
                    }else{
1613
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1614
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
1615
                    }
1616
                }
1617
            }
1618
        }else{
1619
            assert(IS_8X16(mb_type));
1620
            for(list=0; list<h->list_count; list++){
1621
                    for(i=0; i<2; i++){
1622
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1623
                            int ref;
1624
                            if(h->ref_count[list] > 1){
1625
                                ref= decode_cabac_mb_ref( h, list, 4*i );
1626
                                if(ref >= (unsigned)h->ref_count[list]){
1627
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
1628
                                    return -1;
1629
                                }
1630
                            }else
1631
                                ref=0;
1632
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
1633
                        }else
1634
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
1635
                    }
1636
            }
1637
            for(list=0; list<h->list_count; list++){
1638
                for(i=0; i<2; i++){
1639
                    if(IS_DIR(mb_type, i, list)){
1640
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
1641
                        mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
1642
                        my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
1643

    
1644
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
1645
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
1646
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
1647
                    }else{
1648
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1649
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
1650
                    }
1651
                }
1652
            }
1653
        }
1654
    }
1655

    
1656
   if( IS_INTER( mb_type ) ) {
1657
        h->chroma_pred_mode_table[mb_xy] = 0;
1658
        write_back_motion( h, mb_type );
1659
   }
1660

    
1661
    if( !IS_INTRA16x16( mb_type ) ) {
1662
        cbp  = decode_cabac_mb_cbp_luma( h );
1663
        if(CHROMA)
1664
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
1665
    }
1666

    
1667
    h->cbp_table[mb_xy] = h->cbp = cbp;
1668

    
1669
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
1670
        if( decode_cabac_mb_transform_size( h ) )
1671
            mb_type |= MB_TYPE_8x8DCT;
1672
    }
1673
    s->current_picture.mb_type[mb_xy]= mb_type;
1674

    
1675
    if( cbp || IS_INTRA16x16( mb_type ) ) {
1676
        const uint8_t *scan, *scan8x8, *dc_scan;
1677
        const uint32_t *qmul;
1678
        int dqp;
1679

    
1680
        if(IS_INTERLACED(mb_type)){
1681
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
1682
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
1683
            dc_scan= luma_dc_field_scan;
1684
        }else{
1685
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
1686
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1687
            dc_scan= luma_dc_zigzag_scan;
1688
        }
1689

    
1690
        h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
1691
        if( dqp == INT_MIN ){
1692
            av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
1693
            return -1;
1694
        }
1695
        s->qscale += dqp;
1696
        if(((unsigned)s->qscale) > 51){
1697
            if(s->qscale<0) s->qscale+= 52;
1698
            else            s->qscale-= 52;
1699
        }
1700
        h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
1701
        h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
1702

    
1703
        if( IS_INTRA16x16( mb_type ) ) {
1704
            int i;
1705
            //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
1706
            decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16);
1707

    
1708
            if( cbp&15 ) {
1709
                qmul = h->dequant4_coeff[0][s->qscale];
1710
                for( i = 0; i < 16; i++ ) {
1711
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
1712
                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
1713
                }
1714
            } else {
1715
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
1716
            }
1717
        } else {
1718
            int i8x8, i4x4;
1719
            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
1720
                if( cbp & (1<<i8x8) ) {
1721
                    if( IS_8x8DCT(mb_type) ) {
1722
                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
1723
                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
1724
                    } else {
1725
                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
1726
                        for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
1727
                            const int index = 4*i8x8 + i4x4;
1728
                            //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
1729
//START_TIMER
1730
                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
1731
//STOP_TIMER("decode_residual")
1732
                        }
1733
                    }
1734
                } else {
1735
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
1736
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
1737
                }
1738
            }
1739
        }
1740

    
1741
        if( cbp&0x30 ){
1742
            int c;
1743
            for( c = 0; c < 2; c++ ) {
1744
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
1745
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
1746
            }
1747
        }
1748

    
1749
        if( cbp&0x20 ) {
1750
            int c, i;
1751
            for( c = 0; c < 2; c++ ) {
1752
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
1753
                for( i = 0; i < 4; i++ ) {
1754
                    const int index = 16 + 4 * c + i;
1755
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
1756
                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
1757
                }
1758
            }
1759
        } else {
1760
            uint8_t * const nnz= &h->non_zero_count_cache[0];
1761
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1762
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1763
        }
1764
    } else {
1765
        uint8_t * const nnz= &h->non_zero_count_cache[0];
1766
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
1767
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
1768
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
1769
        h->last_qscale_diff = 0;
1770
    }
1771

    
1772
    s->current_picture.qscale_table[mb_xy]= s->qscale;
1773
    write_back_non_zero_count(h);
1774

    
1775
    if(MB_MBAFF){
1776
        h->ref_count[0] >>= 1;
1777
        h->ref_count[1] >>= 1;
1778
    }
1779

    
1780
    return 0;
1781
}