GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/h264_cavlc.c Lines: 457 507 90.1 %
Date: 2021-04-18 21:26:34 Branches: 347 384 90.4 %

Line Branch Exec Source
1
/*
2
 * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
3
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
/**
23
 * @file
24
 * H.264 / AVC / MPEG-4 part10 cavlc bitstream decoding.
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
 */
27
28
#define CABAC(h) 0
29
#define UNCHECKED_BITSTREAM_READER 1
30
31
#include "internal.h"
32
#include "avcodec.h"
33
#include "h264dec.h"
34
#include "h264_mvpred.h"
35
#include "h264data.h"
36
#include "golomb.h"
37
#include "mpegutils.h"
38
#include "libavutil/avassert.h"
39
40
41
static const uint8_t golomb_to_inter_cbp_gray[16]={
42
 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
43
};
44
45
static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
46
15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
47
};
48
49
static const uint8_t chroma_dc_coeff_token_len[4*5]={
50
 2, 0, 0, 0,
51
 6, 1, 0, 0,
52
 6, 6, 3, 0,
53
 6, 7, 7, 6,
54
 6, 8, 8, 7,
55
};
56
57
static const uint8_t chroma_dc_coeff_token_bits[4*5]={
58
 1, 0, 0, 0,
59
 7, 1, 0, 0,
60
 4, 6, 1, 0,
61
 3, 3, 2, 5,
62
 2, 3, 2, 0,
63
};
64
65
static const uint8_t chroma422_dc_coeff_token_len[4*9]={
66
  1,  0,  0,  0,
67
  7,  2,  0,  0,
68
  7,  7,  3,  0,
69
  9,  7,  7,  5,
70
  9,  9,  7,  6,
71
 10, 10,  9,  7,
72
 11, 11, 10,  7,
73
 12, 12, 11, 10,
74
 13, 12, 12, 11,
75
};
76
77
static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
78
  1,   0,  0, 0,
79
 15,   1,  0, 0,
80
 14,  13,  1, 0,
81
  7,  12, 11, 1,
82
  6,   5, 10, 1,
83
  7,   6,  4, 9,
84
  7,   6,  5, 8,
85
  7,   6,  5, 4,
86
  7,   5,  4, 4,
87
};
88
89
static const uint8_t coeff_token_len[4][4*17]={
90
{
91
     1, 0, 0, 0,
92
     6, 2, 0, 0,     8, 6, 3, 0,     9, 8, 7, 5,    10, 9, 8, 6,
93
    11,10, 9, 7,    13,11,10, 8,    13,13,11, 9,    13,13,13,10,
94
    14,14,13,11,    14,14,14,13,    15,15,14,14,    15,15,15,14,
95
    16,15,15,15,    16,16,16,15,    16,16,16,16,    16,16,16,16,
96
},
97
{
98
     2, 0, 0, 0,
99
     6, 2, 0, 0,     6, 5, 3, 0,     7, 6, 6, 4,     8, 6, 6, 4,
100
     8, 7, 7, 5,     9, 8, 8, 6,    11, 9, 9, 6,    11,11,11, 7,
101
    12,11,11, 9,    12,12,12,11,    12,12,12,11,    13,13,13,12,
102
    13,13,13,13,    13,14,13,13,    14,14,14,13,    14,14,14,14,
103
},
104
{
105
     4, 0, 0, 0,
106
     6, 4, 0, 0,     6, 5, 4, 0,     6, 5, 5, 4,     7, 5, 5, 4,
107
     7, 5, 5, 4,     7, 6, 6, 4,     7, 6, 6, 4,     8, 7, 7, 5,
108
     8, 8, 7, 6,     9, 8, 8, 7,     9, 9, 8, 8,     9, 9, 9, 8,
109
    10, 9, 9, 9,    10,10,10,10,    10,10,10,10,    10,10,10,10,
110
},
111
{
112
     6, 0, 0, 0,
113
     6, 6, 0, 0,     6, 6, 6, 0,     6, 6, 6, 6,     6, 6, 6, 6,
114
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
115
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
116
     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
117
}
118
};
119
120
static const uint8_t coeff_token_bits[4][4*17]={
121
{
122
     1, 0, 0, 0,
123
     5, 1, 0, 0,     7, 4, 1, 0,     7, 6, 5, 3,     7, 6, 5, 3,
124
     7, 6, 5, 4,    15, 6, 5, 4,    11,14, 5, 4,     8,10,13, 4,
125
    15,14, 9, 4,    11,10,13,12,    15,14, 9,12,    11,10,13, 8,
126
    15, 1, 9,12,    11,14,13, 8,     7,10, 9,12,     4, 6, 5, 8,
127
},
128
{
129
     3, 0, 0, 0,
130
    11, 2, 0, 0,     7, 7, 3, 0,     7,10, 9, 5,     7, 6, 5, 4,
131
     4, 6, 5, 6,     7, 6, 5, 8,    15, 6, 5, 4,    11,14,13, 4,
132
    15,10, 9, 4,    11,14,13,12,     8,10, 9, 8,    15,14,13,12,
133
    11,10, 9,12,     7,11, 6, 8,     9, 8,10, 1,     7, 6, 5, 4,
134
},
135
{
136
    15, 0, 0, 0,
137
    15,14, 0, 0,    11,15,13, 0,     8,12,14,12,    15,10,11,11,
138
    11, 8, 9,10,     9,14,13, 9,     8,10, 9, 8,    15,14,13,13,
139
    11,14,10,12,    15,10,13,12,    11,14, 9,12,     8,10,13, 8,
140
    13, 7, 9,12,     9,12,11,10,     5, 8, 7, 6,     1, 4, 3, 2,
141
},
142
{
143
     3, 0, 0, 0,
144
     0, 1, 0, 0,     4, 5, 6, 0,     8, 9,10,11,    12,13,14,15,
145
    16,17,18,19,    20,21,22,23,    24,25,26,27,    28,29,30,31,
146
    32,33,34,35,    36,37,38,39,    40,41,42,43,    44,45,46,47,
147
    48,49,50,51,    52,53,54,55,    56,57,58,59,    60,61,62,63,
148
}
149
};
150
151
static const uint8_t total_zeros_len[16][16]= {
152
    {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
153
    {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
154
    {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
155
    {5,3,4,4,3,3,3,4,3,4,5,5,5},
156
    {4,4,4,3,3,3,3,3,4,5,4,5},
157
    {6,5,3,3,3,3,3,3,4,3,6},
158
    {6,5,3,3,3,2,3,4,3,6},
159
    {6,4,5,3,2,2,3,3,6},
160
    {6,6,4,2,2,3,2,5},
161
    {5,5,3,2,2,2,4},
162
    {4,4,3,3,1,3},
163
    {4,4,2,1,3},
164
    {3,3,1,2},
165
    {2,2,1},
166
    {1,1},
167
};
168
169
static const uint8_t total_zeros_bits[16][16]= {
170
    {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
171
    {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
172
    {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
173
    {3,7,5,4,6,5,4,3,3,2,2,1,0},
174
    {5,4,3,7,6,5,4,3,2,1,1,0},
175
    {1,1,7,6,5,4,3,2,1,1,0},
176
    {1,1,5,4,3,3,2,1,1,0},
177
    {1,1,1,3,3,2,2,1,0},
178
    {1,0,1,3,2,1,1,1},
179
    {1,0,1,3,2,1,1},
180
    {0,1,1,2,1,3},
181
    {0,1,1,1,1},
182
    {0,1,1,1},
183
    {0,1,1},
184
    {0,1},
185
};
186
187
static const uint8_t chroma_dc_total_zeros_len[3][4]= {
188
    { 1, 2, 3, 3,},
189
    { 1, 2, 2, 0,},
190
    { 1, 1, 0, 0,},
191
};
192
193
static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
194
    { 1, 1, 1, 0,},
195
    { 1, 1, 0, 0,},
196
    { 1, 0, 0, 0,},
197
};
198
199
static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
200
    { 1, 3, 3, 4, 4, 4, 5, 5 },
201
    { 3, 2, 3, 3, 3, 3, 3 },
202
    { 3, 3, 2, 2, 3, 3 },
203
    { 3, 2, 2, 2, 3 },
204
    { 2, 2, 2, 2 },
205
    { 2, 2, 1 },
206
    { 1, 1 },
207
};
208
209
static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
210
    { 1, 2, 3, 2, 3, 1, 1, 0 },
211
    { 0, 1, 1, 4, 5, 6, 7 },
212
    { 0, 1, 1, 2, 6, 7 },
213
    { 6, 0, 1, 2, 7 },
214
    { 0, 1, 2, 3 },
215
    { 0, 1, 1 },
216
    { 0, 1 },
217
};
218
219
static const uint8_t run_len[7][16]={
220
    {1,1},
221
    {1,2,2},
222
    {2,2,2,2},
223
    {2,2,2,3,3},
224
    {2,2,3,3,3,3},
225
    {2,3,3,3,3,3,3},
226
    {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
227
};
228
229
static const uint8_t run_bits[7][16]={
230
    {1,0},
231
    {1,1,0},
232
    {3,2,1,0},
233
    {3,2,1,1,0},
234
    {3,2,3,2,1,0},
235
    {3,0,1,3,2,5,4},
236
    {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
237
};
238
239
static VLC coeff_token_vlc[4];
240
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
241
static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
242
243
static VLC chroma_dc_coeff_token_vlc;
244
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
245
static const int chroma_dc_coeff_token_vlc_table_size = 256;
246
247
static VLC chroma422_dc_coeff_token_vlc;
248
static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
249
static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
250
251
static VLC total_zeros_vlc[15+1];
252
static VLC_TYPE total_zeros_vlc_tables[15][512][2];
253
static const int total_zeros_vlc_tables_size = 512;
254
255
static VLC chroma_dc_total_zeros_vlc[3+1];
256
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
257
static const int chroma_dc_total_zeros_vlc_tables_size = 8;
258
259
static VLC chroma422_dc_total_zeros_vlc[7+1];
260
static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
261
static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
262
263
static VLC run_vlc[6+1];
264
static VLC_TYPE run_vlc_tables[6][8][2];
265
static const int run_vlc_tables_size = 8;
266
267
static VLC run7_vlc;
268
static VLC_TYPE run7_vlc_table[96][2];
269
static const int run7_vlc_table_size = 96;
270
271
#define LEVEL_TAB_BITS 8
272
static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
273
274
#define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
275
#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
276
#define COEFF_TOKEN_VLC_BITS           8
277
#define TOTAL_ZEROS_VLC_BITS           9
278
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
279
#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
280
#define RUN_VLC_BITS                   3
281
#define RUN7_VLC_BITS                  6
282
283
/**
284
 * Get the predicted number of non-zero coefficients.
285
 * @param n block index
286
 */
287
41953051
static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
288
{
289
41953051
    const int index8= scan8[n];
290
41953051
    const int left = sl->non_zero_count_cache[index8 - 1];
291
41953051
    const int top  = sl->non_zero_count_cache[index8 - 8];
292
41953051
    int i= left + top;
293
294
41953051
    if(i<64) i= (i+1)>>1;
295
296
    ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
297
298
41953051
    return i&31;
299
}
300
301
293
static av_cold void init_cavlc_level_tab(void){
302
    int suffix_length;
303
    unsigned int i;
304
305
2344
    for(suffix_length=0; suffix_length<7; suffix_length++){
306
527107
        for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307
525056
            int prefix= LEVEL_TAB_BITS - av_log2(2*i);
308
309
525056
            if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310
487845
                int level_code = (prefix << suffix_length) +
311
487845
                    (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312
487845
                int mask = -(level_code&1);
313
487845
                level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314
487845
                cavlc_level_tab[suffix_length][i][0]= level_code;
315
487845
                cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316
37211
            }else if(prefix + 1 <= LEVEL_TAB_BITS){
317
35160
                cavlc_level_tab[suffix_length][i][0]= prefix+100;
318
35160
                cavlc_level_tab[suffix_length][i][1]= prefix + 1;
319
            }else{
320
2051
                cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321
2051
                cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322
            }
323
        }
324
    }
325
293
}
326
327
293
av_cold void ff_h264_decode_init_vlc(void)
328
{
329
    int offset;
330
331
293
    chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
332
293
    chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
333
293
    init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
334
             &chroma_dc_coeff_token_len [0], 1, 1,
335
             &chroma_dc_coeff_token_bits[0], 1, 1,
336
             INIT_VLC_USE_NEW_STATIC);
337
338
293
    chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
339
293
    chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
340
293
    init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
341
             &chroma422_dc_coeff_token_len [0], 1, 1,
342
             &chroma422_dc_coeff_token_bits[0], 1, 1,
343
             INIT_VLC_USE_NEW_STATIC);
344
345
293
    offset = 0;
346
1465
    for (int i = 0; i < 4; i++) {
347
1172
        coeff_token_vlc[i].table = coeff_token_vlc_tables + offset;
348
1172
        coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
349
1172
        init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
350
                 &coeff_token_len [i][0], 1, 1,
351
                 &coeff_token_bits[i][0], 1, 1,
352
                 INIT_VLC_USE_NEW_STATIC);
353
1172
        offset += coeff_token_vlc_tables_size[i];
354
    }
355
    /*
356
     * This is a one time safety check to make sure that
357
     * the packed static coeff_token_vlc table sizes
358
     * were initialized correctly.
359
     */
360
293
    av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
361
362
1172
    for (int i = 0; i < 3; i++) {
363
879
        chroma_dc_total_zeros_vlc[i + 1].table = chroma_dc_total_zeros_vlc_tables[i];
364
879
        chroma_dc_total_zeros_vlc[i + 1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
365
879
        init_vlc(&chroma_dc_total_zeros_vlc[i + 1],
366
                 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
367
                 &chroma_dc_total_zeros_len [i][0], 1, 1,
368
                 &chroma_dc_total_zeros_bits[i][0], 1, 1,
369
                 INIT_VLC_USE_NEW_STATIC);
370
    }
371
372
2344
    for (int i = 0; i < 7; i++) {
373
2051
        chroma422_dc_total_zeros_vlc[i + 1].table = chroma422_dc_total_zeros_vlc_tables[i];
374
2051
        chroma422_dc_total_zeros_vlc[i + 1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
375
2051
        init_vlc(&chroma422_dc_total_zeros_vlc[i + 1],
376
                 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
377
                 &chroma422_dc_total_zeros_len [i][0], 1, 1,
378
                 &chroma422_dc_total_zeros_bits[i][0], 1, 1,
379
                 INIT_VLC_USE_NEW_STATIC);
380
    }
381
382
4688
    for (int i = 0; i < 15; i++) {
383
4395
        total_zeros_vlc[i + 1].table = total_zeros_vlc_tables[i];
384
4395
        total_zeros_vlc[i + 1].table_allocated = total_zeros_vlc_tables_size;
385
4395
        init_vlc(&total_zeros_vlc[i + 1],
386
                 TOTAL_ZEROS_VLC_BITS, 16,
387
                 &total_zeros_len [i][0], 1, 1,
388
                 &total_zeros_bits[i][0], 1, 1,
389
                 INIT_VLC_USE_NEW_STATIC);
390
    }
391
392
2051
    for (int i = 0; i < 6; i++) {
393
1758
        run_vlc[i + 1].table = run_vlc_tables[i];
394
1758
        run_vlc[i + 1].table_allocated = run_vlc_tables_size;
395
1758
        init_vlc(&run_vlc[i + 1],
396
                 RUN_VLC_BITS, 7,
397
                 &run_len [i][0], 1, 1,
398
                 &run_bits[i][0], 1, 1,
399
                 INIT_VLC_USE_NEW_STATIC);
400
    }
401
293
    run7_vlc.table = run7_vlc_table;
402
293
    run7_vlc.table_allocated = run7_vlc_table_size;
403
293
    init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
404
             &run_len [6][0], 1, 1,
405
             &run_bits[6][0], 1, 1,
406
             INIT_VLC_USE_NEW_STATIC);
407
408
293
    init_cavlc_level_tab();
409
293
}
410
411
683047
static inline int get_level_prefix(GetBitContext *gb){
412
    unsigned int buf;
413
    int log;
414
415
683047
    OPEN_READER(re, gb);
416
683047
    UPDATE_CACHE(re, gb);
417
683047
    buf=GET_CACHE(re, gb);
418
419
683047
    log= 32 - av_log2(buf);
420
421
683047
    LAST_SKIP_BITS(re, gb, log);
422
683047
    CLOSE_READER(re, gb);
423
424
683047
    return log-1;
425
}
426
427
/**
428
 * Decode a residual block.
429
 * @param n block index
430
 * @param scantable scantable
431
 * @param max_coeff number of coefficients in the block
432
 * @return <0 if an error occurred
433
 */
434
45088163
static int decode_residual(const H264Context *h, H264SliceContext *sl,
435
                           GetBitContext *gb, int16_t *block, int n,
436
                           const uint8_t *scantable, const uint32_t *qmul,
437
                           int max_coeff)
438
{
439
    static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
440
    int level[16];
441
    int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
442
443
    //FIXME put trailing_onex into the context
444
445
45088163
    if(max_coeff <= 8){
446
3135112
        if (max_coeff == 4)
447
2556054
            coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
448
        else
449
579058
            coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
450
3135112
        total_coeff= coeff_token>>2;
451
    }else{
452
41953051
        if(n >= LUMA_DC_BLOCK_INDEX){
453
210603
            total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
454
210603
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
455
210603
            total_coeff= coeff_token>>2;
456
        }else{
457
41742448
            total_coeff= pred_non_zero_count(h, sl, n);
458
41742448
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
459
41742448
            total_coeff= coeff_token>>2;
460
        }
461
    }
462
45088163
    sl->non_zero_count_cache[scan8[n]] = total_coeff;
463
464
    //FIXME set last_non_zero?
465
466
45088163
    if(total_coeff==0)
467
15668411
        return 0;
468
29419752
    if(total_coeff > (unsigned)max_coeff) {
469
        av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
470
        return -1;
471
    }
472
473
29419752
    trailing_ones= coeff_token&3;
474
    ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
475
    av_assert2(total_coeff<=16);
476
477
29419752
    i = show_bits(gb, 3);
478
29419752
    skip_bits(gb, trailing_ones);
479
29419752
    level[0] = 1-((i&4)>>1);
480
29419752
    level[1] = 1-((i&2)   );
481
29419752
    level[2] = 1-((i&1)<<1);
482
483
29419752
    if(trailing_ones<total_coeff) {
484
        int mask, prefix;
485
13389894
        int suffix_length = total_coeff > 10 & trailing_ones < 3;
486
13389894
        int bitsi= show_bits(gb, LEVEL_TAB_BITS);
487
13389894
        int level_code= cavlc_level_tab[suffix_length][bitsi][0];
488
489
13389894
        skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
490
13389894
        if(level_code >= 100){
491
305379
            prefix= level_code - 100;
492
305379
            if(prefix == LEVEL_TAB_BITS)
493
301644
                prefix += get_level_prefix(gb);
494
495
            //first coefficient has suffix_length equal to 0 or 1
496
305379
            if(prefix<14){ //FIXME try to build a large unified VLC table for all this
497
184421
                if(suffix_length)
498
12209
                    level_code= (prefix<<1) + get_bits1(gb); //part
499
                else
500
172212
                    level_code= prefix; //part
501
120958
            }else if(prefix==14){
502
55311
                if(suffix_length)
503
536
                    level_code= (prefix<<1) + get_bits1(gb); //part
504
                else
505
54775
                    level_code= prefix + get_bits(gb, 4); //part
506
            }else{
507
65647
                level_code= 30;
508
65647
                if(prefix>=16){
509
24
                    if(prefix > 25+3){
510
                        av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
511
                        return -1;
512
                    }
513
24
                    level_code += (1<<(prefix-3))-4096;
514
                }
515
65647
                level_code += get_bits(gb, prefix-3); //part
516
            }
517
518
305379
            if(trailing_ones < 3) level_code += 2;
519
520
305379
            suffix_length = 2;
521
305379
            mask= -(level_code&1);
522
305379
            level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
523
        }else{
524
13084515
            level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
525
526
13084515
            suffix_length = 1 + (level_code + 3U > 6U);
527
13084515
            level[trailing_ones]= level_code;
528
        }
529
530
        //remaining coefficients have suffix_length > 0
531
51569106
        for(i=trailing_ones+1;i<total_coeff;i++) {
532
            static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
533
38179212
            int bitsi= show_bits(gb, LEVEL_TAB_BITS);
534
38179212
            level_code= cavlc_level_tab[suffix_length][bitsi][0];
535
536
38179212
            skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
537
38179212
            if(level_code >= 100){
538
765472
                prefix= level_code - 100;
539
765472
                if(prefix == LEVEL_TAB_BITS){
540
381403
                    prefix += get_level_prefix(gb);
541
                }
542
765472
                if(prefix<15){
543
702286
                    level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
544
                }else{
545
63186
                    level_code = 15<<suffix_length;
546
63186
                    if (prefix>=16) {
547
4
                        if(prefix > 25+3){
548
                            av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
549
                            return AVERROR_INVALIDDATA;
550
                        }
551
4
                        level_code += (1<<(prefix-3))-4096;
552
                    }
553
63186
                    level_code += get_bits(gb, prefix-3);
554
                }
555
765472
                mask= -(level_code&1);
556
765472
                level_code= (((2+level_code)>>1) ^ mask) - mask;
557
            }
558
38179212
            level[i]= level_code;
559
38179212
            suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
560
        }
561
    }
562
563
29419752
    if(total_coeff == max_coeff)
564
291828
        zeros_left=0;
565
    else{
566
29127924
        if (max_coeff <= 8) {
567
1867388
            if (max_coeff == 4)
568
1410006
                zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
569
                                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
570
            else
571
457382
                zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
572
                                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
573
        } else {
574
27260536
            zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
575
        }
576
    }
577
578
#define STORE_BLOCK(type) \
579
    scantable += zeros_left + total_coeff - 1; \
580
    if(n >= LUMA_DC_BLOCK_INDEX){ \
581
        ((type*)block)[*scantable] = level[0]; \
582
        for(i=1;i<total_coeff && zeros_left > 0;i++) { \
583
            if(zeros_left < 7) \
584
                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
585
            else \
586
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
587
            zeros_left -= run_before; \
588
            scantable -= 1 + run_before; \
589
            ((type*)block)[*scantable]= level[i]; \
590
        } \
591
        for(;i<total_coeff;i++) { \
592
            scantable--; \
593
            ((type*)block)[*scantable]= level[i]; \
594
        } \
595
    }else{ \
596
        ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
597
        for(i=1;i<total_coeff && zeros_left > 0;i++) { \
598
            if(zeros_left < 7) \
599
                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
600
            else \
601
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
602
            zeros_left -= run_before; \
603
            scantable -= 1 + run_before; \
604
            ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
605
        } \
606
        for(;i<total_coeff;i++) { \
607
            scantable--; \
608
            ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
609
        } \
610
    }
611
612
29419752
    if (h->pixel_shift) {
613




37564146
        STORE_BLOCK(int32_t)
614
    } else {
615




62415682
        STORE_BLOCK(int16_t)
616
    }
617
618
29419752
    if(zeros_left<0){
619
        av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
620
        return -1;
621
    }
622
623
29419752
    return 0;
624
}
625
626
static av_always_inline
627
2806644
int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
628
                         GetBitContext *gb, const uint8_t *scan,
629
                         const uint8_t *scan8x8, int pixel_shift,
630
                         int mb_type, int cbp, int p)
631
{
632
    int i4x4, i8x8;
633
2806644
    int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
634
2806644
    if(IS_INTRA16x16(mb_type)){
635
210603
        AV_ZERO128(sl->mb_luma_dc[p]+0);
636
210603
        AV_ZERO128(sl->mb_luma_dc[p]+8);
637
210603
        AV_ZERO128(sl->mb_luma_dc[p]+16);
638
210603
        AV_ZERO128(sl->mb_luma_dc[p]+24);
639
210603
        if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
640
            return -1; //FIXME continue if partitioned and other return -1 too
641
        }
642
643
        av_assert2((cbp&15) == 0 || (cbp&15) == 15);
644
645
210603
        if(cbp&15){
646
473030
            for(i8x8=0; i8x8<4; i8x8++){
647
1892120
                for(i4x4=0; i4x4<4; i4x4++){
648
1513696
                    const int index= i4x4 + 4*i8x8 + p*16;
649
1513696
                    if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
650
1513696
                        index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
651
                        return -1;
652
                    }
653
                }
654
            }
655
94606
            return 0xf;
656
        }else{
657
115997
            fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
658
115997
            return 0;
659
        }
660
    }else{
661
2596041
        int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
662
        /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
663
2596041
        int new_cbp = 0;
664
12980205
        for(i8x8=0; i8x8<4; i8x8++){
665
10384164
            if(cbp & (1<<i8x8)){
666
7657176
                if(IS_8x8DCT(mb_type)){
667
2320357
                    int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
668
                    uint8_t *nnz;
669
11601785
                    for(i4x4=0; i4x4<4; i4x4++){
670
9281428
                        const int index= i4x4 + 4*i8x8 + p*16;
671
9281428
                        if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
672
9281428
                                            h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
673
                            return -1;
674
                    }
675
2320357
                    nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
676
2320357
                    nnz[0] += nnz[1] + nnz[8] + nnz[9];
677
2320357
                    new_cbp |= !!nnz[0] << i8x8;
678
                }else{
679
26684095
                    for(i4x4=0; i4x4<4; i4x4++){
680
21347276
                        const int index= i4x4 + 4*i8x8 + p*16;
681
21347276
                        if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
682
21347276
                                            scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
683
                            return -1;
684
                        }
685
21347276
                        new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
686
                    }
687
                }
688
            }else{
689
2726988
                uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
690
2726988
                nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
691
            }
692
        }
693
2596041
        return new_cbp;
694
    }
695
}
696
697
4346943
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
698
{
699
    int mb_xy;
700
    int partition_count;
701
    unsigned int mb_type, cbp;
702
4346943
    int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
703

4346943
    const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
704
4346943
    const int pixel_shift = h->pixel_shift;
705
706
4346943
    mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
707
708
    ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
709
4346943
    cbp = 0; /* avoid warning. FIXME: find a solution without slowing
710
                down the code */
711
4346943
    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
712
3338086
        if (sl->mb_skip_run == -1) {
713
2485391
            unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
714
2485391
            if (mb_skip_run > h->mb_num) {
715
                av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
716
                return AVERROR_INVALIDDATA;
717
            }
718
2485391
            sl->mb_skip_run = mb_skip_run;
719
        }
720
721
3338086
        if (sl->mb_skip_run--) {
722

855807
            if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
723
5515
                if (sl->mb_skip_run == 0)
724
2894
                    sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
725
            }
726
855807
            decode_mb_skip(h, sl);
727
855807
            return 0;
728
        }
729
    }
730
3491136
    if (FRAME_MBAFF(h)) {
731
497835
        if ((sl->mb_y & 1) == 0)
732
248957
            sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
733
    }
734
735
3491136
    sl->prev_mb_skipped = 0;
736
737
3491136
    mb_type= get_ue_golomb(&sl->gb);
738
3491136
    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
739
877411
        if(mb_type < 23){
740
736512
            partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
741
736512
            mb_type         = ff_h264_b_mb_type_info[mb_type].type;
742
        }else{
743
140899
            mb_type -= 23;
744
140899
            goto decode_intra_mb;
745
        }
746
2613725
    } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
747
1604868
        if(mb_type < 5){
748
1367646
            partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
749
1367646
            mb_type         = ff_h264_p_mb_type_info[mb_type].type;
750
        }else{
751
237222
            mb_type -= 5;
752
237222
            goto decode_intra_mb;
753
        }
754
    }else{
755
       av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
756

1008857
        if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
757
            mb_type--;
758
1008857
decode_intra_mb:
759
1386978
        if(mb_type > 25){
760
            av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
761
            return -1;
762
        }
763
1386978
        partition_count=0;
764
1386978
        cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
765
1386978
        sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
766
1386978
        mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
767
    }
768
769
3491136
    if (MB_FIELD(sl))
770
981328
        mb_type |= MB_TYPE_INTERLACED;
771
772
3491136
    h->slice_table[mb_xy] = sl->slice_num;
773
774
3491136
    if(IS_INTRA_PCM(mb_type)){
775
17446
        const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
776
17446
                            h->ps.sps->bit_depth_luma;
777
778
        // We assume these blocks are very rare so we do not optimize it.
779
17446
        sl->intra_pcm_ptr = align_get_bits(&sl->gb);
780
17446
        if (get_bits_left(&sl->gb) < mb_size) {
781
            av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
782
            return AVERROR_INVALIDDATA;
783
        }
784
17446
        skip_bits_long(&sl->gb, mb_size);
785
786
        // In deblocking, the quantizer is 0
787
17446
        h->cur_pic.qscale_table[mb_xy] = 0;
788
        // All coeffs are present
789
17446
        memset(h->non_zero_count[mb_xy], 16, 48);
790
791
17446
        h->cur_pic.mb_type[mb_xy] = mb_type;
792
17446
        return 0;
793
    }
794
795
3473690
    fill_decode_neighbors(h, sl, mb_type);
796
3473690
    fill_decode_caches(h, sl, mb_type);
797
798
    //mb_pred
799
3473690
    if(IS_INTRA(mb_type)){
800
        int pred_mode;
801
//            init_top_left_availability(h);
802
1369532
        if(IS_INTRA4x4(mb_type)){
803
            int i;
804
1158929
            int di = 1;
805

1158929
            if(dct8x8_allowed && get_bits1(&sl->gb)){
806
541655
                mb_type |= MB_TYPE_8x8DCT;
807
541655
                di = 4;
808
            }
809
810
//                fill_intra4x4_pred_table(h);
811
13201933
            for(i=0; i<16; i+=di){
812
12043004
                int mode = pred_intra_mode(h, sl, i);
813
814
12043004
                if(!get_bits1(&sl->gb)){
815
6502141
                    const int rem_mode= get_bits(&sl->gb, 3);
816
6502141
                    mode = rem_mode + (rem_mode >= mode);
817
                }
818
819
12043004
                if(di==4)
820
2166620
                    fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
821
                else
822
9876384
                    sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
823
            }
824
1158929
            write_back_intra_pred_mode(h, sl);
825
1158929
            if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
826
1158929
                                                 sl->top_samples_available, sl->left_samples_available) < 0)
827
                return -1;
828
        }else{
829
421206
            sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
830
210603
                                                                     sl->left_samples_available, sl->intra16x16_pred_mode, 0);
831
210603
            if (sl->intra16x16_pred_mode < 0)
832
                return -1;
833
        }
834
1369532
        if(decode_chroma){
835
1342403
            pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
836
1342403
                                                     sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
837
1342403
            if(pred_mode < 0)
838
                return -1;
839
1342403
            sl->chroma_pred_mode = pred_mode;
840
        } else {
841
27129
            sl->chroma_pred_mode = DC_128_PRED8x8;
842
        }
843
2104158
    }else if(partition_count==4){
844
        int i, j, sub_partition_count[4], list, ref[2][4];
845
846
511482
        if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
847
889995
            for(i=0; i<4; i++){
848
711996
                sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
849
711996
                if(sl->sub_mb_type[i] >=13){
850
                    av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
851
                    return -1;
852
                }
853
711996
                sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
854
711996
                sl->sub_mb_type[i]     = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
855
            }
856
177999
            if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
857
55683
                ff_h264_pred_direct_motion(h, sl, &mb_type);
858
55683
                sl->ref_cache[0][scan8[4]] =
859
55683
                sl->ref_cache[1][scan8[4]] =
860
55683
                sl->ref_cache[0][scan8[12]] =
861
55683
                sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
862
            }
863
        }else{
864
            av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
865
1667415
            for(i=0; i<4; i++){
866
1333932
                sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
867
1333932
                if(sl->sub_mb_type[i] >=4){
868
                    av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
869
                    return -1;
870
                }
871
1333932
                sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
872
1333932
                sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
873
            }
874
        }
875
876
1200963
        for (list = 0; list < sl->list_count; list++) {
877
689481
            int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
878
3447405
            for(i=0; i<4; i++){
879
2757924
                if(IS_DIRECT(sl->sub_mb_type[i])) continue;
880
2527266
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
881
                    unsigned int tmp;
882
2200238
                    if(ref_count == 1){
883
756033
                        tmp= 0;
884
1444205
                    }else if(ref_count == 2){
885
454436
                        tmp= get_bits1(&sl->gb)^1;
886
                    }else{
887
989769
                        tmp= get_ue_golomb_31(&sl->gb);
888
989769
                        if(tmp>=ref_count){
889
                            av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
890
                            return -1;
891
                        }
892
                    }
893
2200238
                    ref[list][i]= tmp;
894
                }else{
895
                 //FIXME
896
327028
                    ref[list][i] = -1;
897
                }
898
            }
899
        }
900
901
511482
        if(dct8x8_allowed)
902
51527
            dct8x8_allowed = get_dct8x8_allowed(h, sl);
903
904
1200963
        for (list = 0; list < sl->list_count; list++) {
905
3447405
            for(i=0; i<4; i++){
906
2757924
                if(IS_DIRECT(sl->sub_mb_type[i])) {
907
230658
                    sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
908
230658
                    continue;
909
                }
910
2527266
                sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
911
2527266
                sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
912
913
2527266
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
914
2200238
                    const int sub_mb_type= sl->sub_mb_type[i];
915
2200238
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
916
5863664
                    for(j=0; j<sub_partition_count[i]; j++){
917
                        int mx, my;
918
3663426
                        const int index= 4*i + block_width*j;
919
3663426
                        int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
920
3663426
                        pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
921
3663426
                        mx += (unsigned)get_se_golomb(&sl->gb);
922
3663426
                        my += (unsigned)get_se_golomb(&sl->gb);
923
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
924
925
3663426
                        if(IS_SUB_8X8(sub_mb_type)){
926
1141536
                            mv_cache[ 1 ][0]=
927
1141536
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
928
1141536
                            mv_cache[ 1 ][1]=
929
1141536
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
930
2521890
                        }else if(IS_SUB_8X4(sub_mb_type)){
931
1024318
                            mv_cache[ 1 ][0]= mx;
932
1024318
                            mv_cache[ 1 ][1]= my;
933
1497572
                        }else if(IS_SUB_4X8(sub_mb_type)){
934
688600
                            mv_cache[ 8 ][0]= mx;
935
688600
                            mv_cache[ 8 ][1]= my;
936
                        }
937
3663426
                        mv_cache[ 0 ][0]= mx;
938
3663426
                        mv_cache[ 0 ][1]= my;
939
                    }
940
                }else{
941
327028
                    uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
942
327028
                    p[0] = p[1]=
943
327028
                    p[8] = p[9]= 0;
944
                }
945
            }
946
        }
947
1592676
    }else if(IS_DIRECT(mb_type)){
948
120891
        ff_h264_pred_direct_motion(h, sl, &mb_type);
949
120891
        dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
950
    }else{
951
        int list, mx, my, i;
952
         //FIXME we should set ref_idx_l? to 0 if we use that later ...
953
1471785
        if(IS_16X16(mb_type)){
954
2248906
            for (list = 0; list < sl->list_count; list++) {
955
                    unsigned int val;
956
1254114
                    if(IS_DIR(mb_type, 0, list)){
957
1050560
                        unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
958
1050560
                        if (rc == 1) {
959
550783
                            val= 0;
960
499777
                        } else if (rc == 2) {
961
135504
                            val= get_bits1(&sl->gb)^1;
962
                        }else{
963
364273
                            val= get_ue_golomb_31(&sl->gb);
964
364273
                            if (val >= rc) {
965
                                av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
966
                                return -1;
967
                            }
968
                        }
969
1050560
                    fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
970
                    }
971
            }
972
2248906
            for (list = 0; list < sl->list_count; list++) {
973
1254114
                if(IS_DIR(mb_type, 0, list)){
974
1050560
                    pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
975
1050560
                    mx += (unsigned)get_se_golomb(&sl->gb);
976
1050560
                    my += (unsigned)get_se_golomb(&sl->gb);
977
                    ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
978
979
1050560
                    fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
980
                }
981
            }
982
        }
983
476993
        else if(IS_16X8(mb_type)){
984
603529
            for (list = 0; list < sl->list_count; list++) {
985
1052904
                    for(i=0; i<2; i++){
986
                        unsigned int val;
987
701936
                        if(IS_DIR(mb_type, i, list)){
988
547878
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
989
547878
                            if (rc == 1) {
990
204911
                                val= 0;
991
342967
                            } else if (rc == 2) {
992
80255
                                val= get_bits1(&sl->gb)^1;
993
                            }else{
994
262712
                                val= get_ue_golomb_31(&sl->gb);
995
262712
                                if (val >= rc) {
996
                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
997
                                    return -1;
998
                                }
999
                            }
1000
                        }else
1001
154058
                            val= LIST_NOT_USED&0xFF;
1002
701936
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1003
                    }
1004
            }
1005
603529
            for (list = 0; list < sl->list_count; list++) {
1006
1052904
                for(i=0; i<2; i++){
1007
                    unsigned int val;
1008
701936
                    if(IS_DIR(mb_type, i, list)){
1009
547878
                        pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1010
547878
                        mx += (unsigned)get_se_golomb(&sl->gb);
1011
547878
                        my += (unsigned)get_se_golomb(&sl->gb);
1012
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1013
1014
547878
                        val= pack16to32(mx,my);
1015
                    }else
1016
154058
                        val=0;
1017
701936
                    fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1018
                }
1019
            }
1020
        }else{
1021
            av_assert2(IS_8X16(mb_type));
1022
528757
            for (list = 0; list < sl->list_count; list++) {
1023
912975
                    for(i=0; i<2; i++){
1024
                        unsigned int val;
1025
608650
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1026
482052
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1027
482052
                            if (rc == 1) {
1028
180611
                                val= 0;
1029
301441
                            } else if (rc == 2) {
1030
82740
                                val= get_bits1(&sl->gb)^1;
1031
                            }else{
1032
218701
                                val= get_ue_golomb_31(&sl->gb);
1033
218701
                                if (val >= rc) {
1034
                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1035
                                    return -1;
1036
                                }
1037
                            }
1038
                        }else
1039
126598
                            val= LIST_NOT_USED&0xFF;
1040
608650
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1041
                    }
1042
            }
1043
528757
            for (list = 0; list < sl->list_count; list++) {
1044
912975
                for(i=0; i<2; i++){
1045
                    unsigned int val;
1046
608650
                    if(IS_DIR(mb_type, i, list)){
1047
482052
                        pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1048
482052
                        mx += (unsigned)get_se_golomb(&sl->gb);
1049
482052
                        my += (unsigned)get_se_golomb(&sl->gb);
1050
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1051
1052
482052
                        val= pack16to32(mx,my);
1053
                    }else
1054
126598
                        val=0;
1055
608650
                    fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1056
                }
1057
            }
1058
        }
1059
    }
1060
1061
3473690
    if(IS_INTER(mb_type))
1062
2104158
        write_back_motion(h, sl, mb_type);
1063
1064
3473690
    if(!IS_INTRA16x16(mb_type)){
1065
3263087
        cbp= get_ue_golomb(&sl->gb);
1066
1067
3263087
        if(decode_chroma){
1068
3223737
            if(cbp > 47){
1069
                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1070
                return -1;
1071
            }
1072
3223737
            if (IS_INTRA4x4(mb_type))
1073
1134780
                cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1074
            else
1075
2088957
                cbp = ff_h264_golomb_to_inter_cbp[cbp];
1076
        }else{
1077
39350
            if(cbp > 15){
1078
                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1079
                return -1;
1080
            }
1081
39350
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1082
15201
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
1083
        }
1084
    } else {
1085

210603
        if (!decode_chroma && cbp>15) {
1086
            av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1087
            return AVERROR_INVALIDDATA;
1088
        }
1089
    }
1090
1091

3473690
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1092
272479
        mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1093
    }
1094
3473690
    sl->cbp=
1095
3473690
    h->cbp_table[mb_xy]= cbp;
1096
3473690
    h->cur_pic.mb_type[mb_xy] = mb_type;
1097
1098

6280334
    if(cbp || IS_INTRA16x16(mb_type)){
1099
        int i4x4, i8x8, chroma_idx;
1100
        int dquant;
1101
        int ret;
1102
2806644
        GetBitContext *gb = &sl->gb;
1103
        const uint8_t *scan, *scan8x8;
1104
2806644
        const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1105
1106
2806644
        dquant= get_se_golomb(&sl->gb);
1107
1108
2806644
        sl->qscale += (unsigned)dquant;
1109
1110
2806644
        if (((unsigned)sl->qscale) > max_qp){
1111
8070
            if (sl->qscale < 0) sl->qscale += max_qp + 1;
1112
4210
            else                sl->qscale -= max_qp+1;
1113
8070
            if (((unsigned)sl->qscale) > max_qp){
1114
                av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1115
                sl->qscale = max_qp;
1116
                return -1;
1117
            }
1118
        }
1119
1120
2806644
        sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1121
2806644
        sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1122
1123
2806644
        if(IS_INTERLACED(mb_type)){
1124
824163
            scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1125
824163
            scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1126
        }else{
1127
1982481
            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1128
1982481
            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1129
        }
1130
1131
2806644
        if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1132
            return -1;
1133
        }
1134
2806644
        h->cbp_table[mb_xy] |= ret << 12;
1135
2806644
        if (CHROMA444(h)) {
1136
            if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1137
                return -1;
1138
            }
1139
            if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1140
                return -1;
1141
            }
1142
        } else {
1143
2806644
            const int num_c8x8 = h->ps.sps->chroma_format_idc;
1144
1145
2806644
            if(cbp&0x30){
1146
4702668
                for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1147
3135112
                    if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1148
                                        CHROMA_DC_BLOCK_INDEX + chroma_idx,
1149
3135112
                                        CHROMA422(h) ? ff_h264_chroma422_dc_scan : ff_h264_chroma_dc_scan,
1150
                                        NULL, 4 * num_c8x8) < 0) {
1151
                        return -1;
1152
                    }
1153
            }
1154
1155
2806644
            if(cbp&0x20){
1156
3019302
                for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157
2012868
                    const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1158
2012868
                    int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1159
4412880
                    for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1160
12000060
                        for (i4x4 = 0; i4x4 < 4; i4x4++) {
1161
9600048
                            const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1162
9600048
                            if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1163
                                return -1;
1164
9600048
                            mb += 16 << pixel_shift;
1165
                        }
1166
                    }
1167
                }
1168
            }else{
1169
1800210
                fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170
1800210
                fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1171
            }
1172
        }
1173
    }else{
1174
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1177
    }
1178
3473690
    h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1179
3473690
    write_back_non_zero_count(h, sl);
1180
1181
3473690
    return 0;
1182
}