GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/h264_cavlc.c Lines: 471 509 92.5 %
Date: 2019-11-22 03:34:36 Branches: 354 386 91.7 %

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
41947301
static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
288
{
289
41947301
    const int index8= scan8[n];
290
41947301
    const int left = sl->non_zero_count_cache[index8 - 1];
291
41947301
    const int top  = sl->non_zero_count_cache[index8 - 8];
292
41947301
    int i= left + top;
293
294
41947301
    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
41947301
    return i&31;
299
}
300
301
284
static av_cold void init_cavlc_level_tab(void){
302
    int suffix_length;
303
    unsigned int i;
304
305
2272
    for(suffix_length=0; suffix_length<7; suffix_length++){
306
510916
        for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307
508928
            int prefix= LEVEL_TAB_BITS - av_log2(2*i);
308
309
508928
            if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310
472860
                int level_code = (prefix << suffix_length) +
311
472860
                    (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312
472860
                int mask = -(level_code&1);
313
472860
                level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314
472860
                cavlc_level_tab[suffix_length][i][0]= level_code;
315
472860
                cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316
36068
            }else if(prefix + 1 <= LEVEL_TAB_BITS){
317
34080
                cavlc_level_tab[suffix_length][i][0]= prefix+100;
318
34080
                cavlc_level_tab[suffix_length][i][1]= prefix + 1;
319
            }else{
320
1988
                cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321
1988
                cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322
            }
323
        }
324
    }
325
284
}
326
327
284
av_cold void ff_h264_decode_init_vlc(void){
328
    static int done = 0;
329
330
284
    if (!done) {
331
        int i;
332
        int offset;
333
284
        done = 1;
334
335
284
        chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
336
284
        chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
337
284
        init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
338
                 &chroma_dc_coeff_token_len [0], 1, 1,
339
                 &chroma_dc_coeff_token_bits[0], 1, 1,
340
                 INIT_VLC_USE_NEW_STATIC);
341
342
284
        chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
343
284
        chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
344
284
        init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
345
                 &chroma422_dc_coeff_token_len [0], 1, 1,
346
                 &chroma422_dc_coeff_token_bits[0], 1, 1,
347
                 INIT_VLC_USE_NEW_STATIC);
348
349
284
        offset = 0;
350
1420
        for(i=0; i<4; i++){
351
1136
            coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
352
1136
            coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
353
1136
            init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
354
                     &coeff_token_len [i][0], 1, 1,
355
                     &coeff_token_bits[i][0], 1, 1,
356
                     INIT_VLC_USE_NEW_STATIC);
357
1136
            offset += coeff_token_vlc_tables_size[i];
358
        }
359
        /*
360
         * This is a one time safety check to make sure that
361
         * the packed static coeff_token_vlc table sizes
362
         * were initialized correctly.
363
         */
364
284
        av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
365
366
1136
        for(i=0; i<3; i++){
367
852
            chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
368
852
            chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369
852
            init_vlc(&chroma_dc_total_zeros_vlc[i+1],
370
                     CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
371
                     &chroma_dc_total_zeros_len [i][0], 1, 1,
372
                     &chroma_dc_total_zeros_bits[i][0], 1, 1,
373
                     INIT_VLC_USE_NEW_STATIC);
374
        }
375
376
2272
        for(i=0; i<7; i++){
377
1988
            chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
378
1988
            chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379
1988
            init_vlc(&chroma422_dc_total_zeros_vlc[i+1],
380
                     CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
381
                     &chroma422_dc_total_zeros_len [i][0], 1, 1,
382
                     &chroma422_dc_total_zeros_bits[i][0], 1, 1,
383
                     INIT_VLC_USE_NEW_STATIC);
384
        }
385
386
4544
        for(i=0; i<15; i++){
387
4260
            total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
388
4260
            total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
389
4260
            init_vlc(&total_zeros_vlc[i+1],
390
                     TOTAL_ZEROS_VLC_BITS, 16,
391
                     &total_zeros_len [i][0], 1, 1,
392
                     &total_zeros_bits[i][0], 1, 1,
393
                     INIT_VLC_USE_NEW_STATIC);
394
        }
395
396
1988
        for(i=0; i<6; i++){
397
1704
            run_vlc[i+1].table = run_vlc_tables[i];
398
1704
            run_vlc[i+1].table_allocated = run_vlc_tables_size;
399
1704
            init_vlc(&run_vlc[i+1],
400
                     RUN_VLC_BITS, 7,
401
                     &run_len [i][0], 1, 1,
402
                     &run_bits[i][0], 1, 1,
403
                     INIT_VLC_USE_NEW_STATIC);
404
        }
405
284
        run7_vlc.table = run7_vlc_table,
406
284
        run7_vlc.table_allocated = run7_vlc_table_size;
407
284
        init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
408
                 &run_len [6][0], 1, 1,
409
                 &run_bits[6][0], 1, 1,
410
                 INIT_VLC_USE_NEW_STATIC);
411
412
284
        init_cavlc_level_tab();
413
    }
414
284
}
415
416
683034
static inline int get_level_prefix(GetBitContext *gb){
417
    unsigned int buf;
418
    int log;
419
420
683034
    OPEN_READER(re, gb);
421
683034
    UPDATE_CACHE(re, gb);
422
683034
    buf=GET_CACHE(re, gb);
423
424
683034
    log= 32 - av_log2(buf);
425
426
683034
    LAST_SKIP_BITS(re, gb, log);
427
683034
    CLOSE_READER(re, gb);
428
429
683034
    return log-1;
430
}
431
432
/**
433
 * Decode a residual block.
434
 * @param n block index
435
 * @param scantable scantable
436
 * @param max_coeff number of coefficients in the block
437
 * @return <0 if an error occurred
438
 */
439
45082015
static int decode_residual(const H264Context *h, H264SliceContext *sl,
440
                           GetBitContext *gb, int16_t *block, int n,
441
                           const uint8_t *scantable, const uint32_t *qmul,
442
                           int max_coeff)
443
{
444
    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};
445
    int level[16];
446
    int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
447
448
    //FIXME put trailing_onex into the context
449
450
45082015
    if(max_coeff <= 8){
451
3134714
        if (max_coeff == 4)
452
2555656
            coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
453
        else
454
579058
            coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
455
3134714
        total_coeff= coeff_token>>2;
456
    }else{
457
41947301
        if(n >= LUMA_DC_BLOCK_INDEX){
458
210609
            total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
459
210609
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
460
210609
            total_coeff= coeff_token>>2;
461
        }else{
462
41736692
            total_coeff= pred_non_zero_count(h, sl, n);
463
41736692
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
464
41736692
            total_coeff= coeff_token>>2;
465
        }
466
    }
467
45082015
    sl->non_zero_count_cache[scan8[n]] = total_coeff;
468
469
    //FIXME set last_non_zero?
470
471
45082015
    if(total_coeff==0)
472
15665836
        return 0;
473
29416179
    if(total_coeff > (unsigned)max_coeff) {
474
        av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
475
        return -1;
476
    }
477
478
29416179
    trailing_ones= coeff_token&3;
479
    ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
480
    av_assert2(total_coeff<=16);
481
482
29416179
    i = show_bits(gb, 3);
483
29416179
    skip_bits(gb, trailing_ones);
484
29416179
    level[0] = 1-((i&4)>>1);
485
29416179
    level[1] = 1-((i&2)   );
486
29416179
    level[2] = 1-((i&1)<<1);
487
488
29416179
    if(trailing_ones<total_coeff) {
489
        int mask, prefix;
490
13389016
        int suffix_length = total_coeff > 10 & trailing_ones < 3;
491
13389016
        int bitsi= show_bits(gb, LEVEL_TAB_BITS);
492
13389016
        int level_code= cavlc_level_tab[suffix_length][bitsi][0];
493
494
13389016
        skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
495
13389016
        if(level_code >= 100){
496
305369
            prefix= level_code - 100;
497
305369
            if(prefix == LEVEL_TAB_BITS)
498
301634
                prefix += get_level_prefix(gb);
499
500
            //first coefficient has suffix_length equal to 0 or 1
501
305369
            if(prefix<14){ //FIXME try to build a large unified VLC table for all this
502
184411
                if(suffix_length)
503
12209
                    level_code= (prefix<<1) + get_bits1(gb); //part
504
                else
505
172202
                    level_code= prefix; //part
506
120958
            }else if(prefix==14){
507
55311
                if(suffix_length)
508
536
                    level_code= (prefix<<1) + get_bits1(gb); //part
509
                else
510
54775
                    level_code= prefix + get_bits(gb, 4); //part
511
            }else{
512
65647
                level_code= 30;
513
65647
                if(prefix>=16){
514
24
                    if(prefix > 25+3){
515
                        av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
516
                        return -1;
517
                    }
518
24
                    level_code += (1<<(prefix-3))-4096;
519
                }
520
65647
                level_code += get_bits(gb, prefix-3); //part
521
            }
522
523
305369
            if(trailing_ones < 3) level_code += 2;
524
525
305369
            suffix_length = 2;
526
305369
            mask= -(level_code&1);
527
305369
            level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
528
        }else{
529
13083647
            level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
530
531
13083647
            suffix_length = 1 + (level_code + 3U > 6U);
532
13083647
            level[trailing_ones]= level_code;
533
        }
534
535
        //remaining coefficients have suffix_length > 0
536
51566796
        for(i=trailing_ones+1;i<total_coeff;i++) {
537
            static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
538
38177780
            int bitsi= show_bits(gb, LEVEL_TAB_BITS);
539
38177780
            level_code= cavlc_level_tab[suffix_length][bitsi][0];
540
541
38177780
            skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
542
38177780
            if(level_code >= 100){
543
765470
                prefix= level_code - 100;
544
765470
                if(prefix == LEVEL_TAB_BITS){
545
381400
                    prefix += get_level_prefix(gb);
546
                }
547
765470
                if(prefix<15){
548
702284
                    level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
549
                }else{
550
63186
                    level_code = 15<<suffix_length;
551
63186
                    if (prefix>=16) {
552
4
                        if(prefix > 25+3){
553
                            av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
554
                            return AVERROR_INVALIDDATA;
555
                        }
556
4
                        level_code += (1<<(prefix-3))-4096;
557
                    }
558
63186
                    level_code += get_bits(gb, prefix-3);
559
                }
560
765470
                mask= -(level_code&1);
561
765470
                level_code= (((2+level_code)>>1) ^ mask) - mask;
562
            }
563
38177780
            level[i]= level_code;
564
38177780
            suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
565
        }
566
    }
567
568
29416179
    if(total_coeff == max_coeff)
569
291828
        zeros_left=0;
570
    else{
571
29124351
        if (max_coeff <= 8) {
572
1867233
            if (max_coeff == 4)
573
1409851
                zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
574
                                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
575
            else
576
457382
                zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
577
                                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
578
        } else {
579
27257118
            zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
580
        }
581
    }
582
583
#define STORE_BLOCK(type) \
584
    scantable += zeros_left + total_coeff - 1; \
585
    if(n >= LUMA_DC_BLOCK_INDEX){ \
586
        ((type*)block)[*scantable] = level[0]; \
587
        for(i=1;i<total_coeff && zeros_left > 0;i++) { \
588
            if(zeros_left < 7) \
589
                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
590
            else \
591
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
592
            zeros_left -= run_before; \
593
            scantable -= 1 + run_before; \
594
            ((type*)block)[*scantable]= level[i]; \
595
        } \
596
        for(;i<total_coeff;i++) { \
597
            scantable--; \
598
            ((type*)block)[*scantable]= level[i]; \
599
        } \
600
    }else{ \
601
        ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
602
        for(i=1;i<total_coeff && zeros_left > 0;i++) { \
603
            if(zeros_left < 7) \
604
                run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
605
            else \
606
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
607
            zeros_left -= run_before; \
608
            scantable -= 1 + run_before; \
609
            ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
610
        } \
611
        for(;i<total_coeff;i++) { \
612
            scantable--; \
613
            ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
614
        } \
615
    }
616
617
29416179
    if (h->pixel_shift) {
618




37564146
        STORE_BLOCK(int32_t)
619
    } else {
620




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

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

855973
            if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
728
5515
                if (sl->mb_skip_run == 0)
729
2894
                    sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
730
            }
731
855973
            decode_mb_skip(h, sl);
732
855973
            return 0;
733
        }
734
    }
735
3490250
    if (FRAME_MBAFF(h)) {
736
497835
        if ((sl->mb_y & 1) == 0)
737
248957
            sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
738
    }
739
740
3490250
    sl->prev_mb_skipped = 0;
741
742
3490250
    mb_type= get_ue_golomb(&sl->gb);
743
3490250
    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
744
877411
        if(mb_type < 23){
745
736512
            partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
746
736512
            mb_type         = ff_h264_b_mb_type_info[mb_type].type;
747
        }else{
748
140899
            mb_type -= 23;
749
140899
            goto decode_intra_mb;
750
        }
751
2612839
    } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
752
1603977
        if(mb_type < 5){
753
1366739
            partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
754
1366739
            mb_type         = ff_h264_p_mb_type_info[mb_type].type;
755
        }else{
756
237238
            mb_type -= 5;
757
237238
            goto decode_intra_mb;
758
        }
759
    }else{
760
       av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
761

1008862
        if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
762
            mb_type--;
763
1008862
decode_intra_mb:
764
1386999
        if(mb_type > 25){
765
3
            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);
766
3
            return -1;
767
        }
768
1386996
        partition_count=0;
769
1386996
        cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
770
1386996
        sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
771
1386996
        mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
772
    }
773
774
3490247
    if (MB_FIELD(sl))
775
981328
        mb_type |= MB_TYPE_INTERLACED;
776
777
3490247
    h->slice_table[mb_xy] = sl->slice_num;
778
779
3490247
    if(IS_INTRA_PCM(mb_type)){
780
17446
        const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
781
17446
                            h->ps.sps->bit_depth_luma;
782
783
        // We assume these blocks are very rare so we do not optimize it.
784
17446
        sl->intra_pcm_ptr = align_get_bits(&sl->gb);
785
17446
        if (get_bits_left(&sl->gb) < mb_size) {
786
            av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
787
            return AVERROR_INVALIDDATA;
788
        }
789
17446
        skip_bits_long(&sl->gb, mb_size);
790
791
        // In deblocking, the quantizer is 0
792
17446
        h->cur_pic.qscale_table[mb_xy] = 0;
793
        // All coeffs are present
794
17446
        memset(h->non_zero_count[mb_xy], 16, 48);
795
796
17446
        h->cur_pic.mb_type[mb_xy] = mb_type;
797
17446
        return 0;
798
    }
799
800
3472801
    fill_decode_neighbors(h, sl, mb_type);
801
3472801
    fill_decode_caches(h, sl, mb_type);
802
803
    //mb_pred
804
3472801
    if(IS_INTRA(mb_type)){
805
        int pred_mode;
806
//            init_top_left_availability(h);
807
1369550
        if(IS_INTRA4x4(mb_type)){
808
            int i;
809
1158933
            int di = 1;
810

1158933
            if(dct8x8_allowed && get_bits1(&sl->gb)){
811
541655
                mb_type |= MB_TYPE_8x8DCT;
812
541655
                di = 4;
813
            }
814
815
//                fill_intra4x4_pred_table(h);
816
13202001
            for(i=0; i<16; i+=di){
817
12043068
                int mode = pred_intra_mode(h, sl, i);
818
819
12043068
                if(!get_bits1(&sl->gb)){
820
6502176
                    const int rem_mode= get_bits(&sl->gb, 3);
821
6502176
                    mode = rem_mode + (rem_mode >= mode);
822
                }
823
824
12043068
                if(di==4)
825
2166620
                    fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
826
                else
827
9876448
                    sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
828
            }
829
1158933
            write_back_intra_pred_mode(h, sl);
830
1158933
            if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
831
1158933
                                                 sl->top_samples_available, sl->left_samples_available) < 0)
832
                return -1;
833
        }else{
834
421234
            sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
835
210617
                                                                     sl->left_samples_available, sl->intra16x16_pred_mode, 0);
836
210617
            if (sl->intra16x16_pred_mode < 0)
837
4
                return -1;
838
        }
839
1369546
        if(decode_chroma){
840
1342417
            pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
841
1342417
                                                     sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
842
1342417
            if(pred_mode < 0)
843
4
                return -1;
844
1342413
            sl->chroma_pred_mode = pred_mode;
845
        } else {
846
27129
            sl->chroma_pred_mode = DC_128_PRED8x8;
847
        }
848
2103251
    }else if(partition_count==4){
849
        int i, j, sub_partition_count[4], list, ref[2][4];
850
851
511462
        if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
852
889995
            for(i=0; i<4; i++){
853
711996
                sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
854
711996
                if(sl->sub_mb_type[i] >=13){
855
                    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);
856
1
                    return -1;
857
                }
858
711996
                sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
859
711996
                sl->sub_mb_type[i]     = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
860
            }
861
177999
            if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
862
55683
                ff_h264_pred_direct_motion(h, sl, &mb_type);
863
55683
                sl->ref_cache[0][scan8[4]] =
864
55683
                sl->ref_cache[1][scan8[4]] =
865
55683
                sl->ref_cache[0][scan8[12]] =
866
55683
                sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
867
            }
868
        }else{
869
            av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
870
1667314
            for(i=0; i<4; i++){
871
1333852
                sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
872
1333852
                if(sl->sub_mb_type[i] >=4){
873
1
                    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);
874
1
                    return -1;
875
                }
876
1333851
                sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
877
1333851
                sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
878
            }
879
        }
880
881
1200921
        for (list = 0; list < sl->list_count; list++) {
882
689460
            int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
883
3447300
            for(i=0; i<4; i++){
884
2757840
                if(IS_DIRECT(sl->sub_mb_type[i])) continue;
885
2527182
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
886
                    unsigned int tmp;
887
2200154
                    if(ref_count == 1){
888
755961
                        tmp= 0;
889
1444193
                    }else if(ref_count == 2){
890
454436
                        tmp= get_bits1(&sl->gb)^1;
891
                    }else{
892
989757
                        tmp= get_ue_golomb_31(&sl->gb);
893
989757
                        if(tmp>=ref_count){
894
                            av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
895
                            return -1;
896
                        }
897
                    }
898
2200154
                    ref[list][i]= tmp;
899
                }else{
900
                 //FIXME
901
327028
                    ref[list][i] = -1;
902
                }
903
            }
904
        }
905
906
511461
        if(dct8x8_allowed)
907
51527
            dct8x8_allowed = get_dct8x8_allowed(h, sl);
908
909
1200921
        for (list = 0; list < sl->list_count; list++) {
910
3447300
            for(i=0; i<4; i++){
911
2757840
                if(IS_DIRECT(sl->sub_mb_type[i])) {
912
230658
                    sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
913
230658
                    continue;
914
                }
915
2527182
                sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
916
2527182
                sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
917
918
2527182
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
919
2200154
                    const int sub_mb_type= sl->sub_mb_type[i];
920
2200154
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
921
5863498
                    for(j=0; j<sub_partition_count[i]; j++){
922
                        int mx, my;
923
3663344
                        const int index= 4*i + block_width*j;
924
3663344
                        int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
925
3663344
                        pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
926
3663344
                        mx += (unsigned)get_se_golomb(&sl->gb);
927
3663344
                        my += (unsigned)get_se_golomb(&sl->gb);
928
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
929
930
3663344
                        if(IS_SUB_8X8(sub_mb_type)){
931
1141450
                            mv_cache[ 1 ][0]=
932
1141450
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
933
1141450
                            mv_cache[ 1 ][1]=
934
1141450
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
935
2521894
                        }else if(IS_SUB_8X4(sub_mb_type)){
936
1024320
                            mv_cache[ 1 ][0]= mx;
937
1024320
                            mv_cache[ 1 ][1]= my;
938
1497574
                        }else if(IS_SUB_4X8(sub_mb_type)){
939
688602
                            mv_cache[ 8 ][0]= mx;
940
688602
                            mv_cache[ 8 ][1]= my;
941
                        }
942
3663344
                        mv_cache[ 0 ][0]= mx;
943
3663344
                        mv_cache[ 0 ][1]= my;
944
                    }
945
                }else{
946
327028
                    uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
947
327028
                    p[0] = p[1]=
948
327028
                    p[8] = p[9]= 0;
949
                }
950
            }
951
        }
952
1591789
    }else if(IS_DIRECT(mb_type)){
953
120891
        ff_h264_pred_direct_motion(h, sl, &mb_type);
954
120891
        dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
955
    }else{
956
        int list, mx, my, i;
957
         //FIXME we should set ref_idx_l? to 0 if we use that later ...
958
1470898
        if(IS_16X16(mb_type)){
959
2247880
            for (list = 0; list < sl->list_count; list++) {
960
                    unsigned int val;
961
1253601
                    if(IS_DIR(mb_type, 0, list)){
962
1050047
                        unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
963
1050047
                        if (rc == 1) {
964
550809
                            val= 0;
965
499238
                        } else if (rc == 2) {
966
135504
                            val= get_bits1(&sl->gb)^1;
967
                        }else{
968
363734
                            val= get_ue_golomb_31(&sl->gb);
969
363734
                            if (val >= rc) {
970
                                av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
971
1
                                return -1;
972
                            }
973
                        }
974
1050047
                    fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
975
                    }
976
            }
977
2247880
            for (list = 0; list < sl->list_count; list++) {
978
1253601
                if(IS_DIR(mb_type, 0, list)){
979
1050047
                    pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
980
1050047
                    mx += (unsigned)get_se_golomb(&sl->gb);
981
1050047
                    my += (unsigned)get_se_golomb(&sl->gb);
982
                    ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
983
984
1050047
                    fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
985
                }
986
            }
987
        }
988
476619
        else if(IS_16X8(mb_type)){
989
603194
            for (list = 0; list < sl->list_count; list++) {
990
1052401
                    for(i=0; i<2; i++){
991
                        unsigned int val;
992
701601
                        if(IS_DIR(mb_type, i, list)){
993
547543
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
994
547543
                            if (rc == 1) {
995
204943
                                val= 0;
996
342600
                            } else if (rc == 2) {
997
80255
                                val= get_bits1(&sl->gb)^1;
998
                            }else{
999
262345
                                val= get_ue_golomb_31(&sl->gb);
1000
262345
                                if (val >= rc) {
1001
1
                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1002
1
                                    return -1;
1003
                                }
1004
                            }
1005
                        }else
1006
154058
                            val= LIST_NOT_USED&0xFF;
1007
701600
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1008
                    }
1009
            }
1010
603193
            for (list = 0; list < sl->list_count; list++) {
1011
1052400
                for(i=0; i<2; i++){
1012
                    unsigned int val;
1013
701600
                    if(IS_DIR(mb_type, i, list)){
1014
547542
                        pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1015
547542
                        mx += (unsigned)get_se_golomb(&sl->gb);
1016
547542
                        my += (unsigned)get_se_golomb(&sl->gb);
1017
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1018
1019
547542
                        val= pack16to32(mx,my);
1020
                    }else
1021
154058
                        val=0;
1022
701600
                    fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1023
                }
1024
            }
1025
        }else{
1026
            av_assert2(IS_8X16(mb_type));
1027
528343
            for (list = 0; list < sl->list_count; list++) {
1028
912354
                    for(i=0; i<2; i++){
1029
                        unsigned int val;
1030
608236
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1031
481638
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1032
481638
                            if (rc == 1) {
1033
180637
                                val= 0;
1034
301001
                            } else if (rc == 2) {
1035
82740
                                val= get_bits1(&sl->gb)^1;
1036
                            }else{
1037
218261
                                val= get_ue_golomb_31(&sl->gb);
1038
218261
                                if (val >= rc) {
1039
                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1040
                                    return -1;
1041
                                }
1042
                            }
1043
                        }else
1044
126598
                            val= LIST_NOT_USED&0xFF;
1045
608236
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1046
                    }
1047
            }
1048
528343
            for (list = 0; list < sl->list_count; list++) {
1049
912354
                for(i=0; i<2; i++){
1050
                    unsigned int val;
1051
608236
                    if(IS_DIR(mb_type, i, list)){
1052
481638
                        pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1053
481638
                        mx += (unsigned)get_se_golomb(&sl->gb);
1054
481638
                        my += (unsigned)get_se_golomb(&sl->gb);
1055
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1056
1057
481638
                        val= pack16to32(mx,my);
1058
                    }else
1059
126598
                        val=0;
1060
608236
                    fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1061
                }
1062
            }
1063
        }
1064
    }
1065
1066
3472791
    if(IS_INTER(mb_type))
1067
2103249
        write_back_motion(h, sl, mb_type);
1068
1069
3472791
    if(!IS_INTRA16x16(mb_type)){
1070
3262182
        cbp= get_ue_golomb(&sl->gb);
1071
1072
3262182
        if(decode_chroma){
1073
3222832
            if(cbp > 47){
1074
1
                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1075
1
                return -1;
1076
            }
1077
3222831
            if (IS_INTRA4x4(mb_type))
1078
1134784
                cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1079
            else
1080
2088047
                cbp = ff_h264_golomb_to_inter_cbp[cbp];
1081
        }else{
1082
39350
            if(cbp > 15){
1083
                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1084
                return -1;
1085
            }
1086
39350
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1087
15201
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
1088
        }
1089
    } else {
1090

210609
        if (!decode_chroma && cbp>15) {
1091
            av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1092
            return AVERROR_INVALIDDATA;
1093
        }
1094
    }
1095
1096

3472790
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1097
272479
        mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1098
    }
1099
3472790
    sl->cbp=
1100
3472790
    h->cbp_table[mb_xy]= cbp;
1101
3472790
    h->cur_pic.mb_type[mb_xy] = mb_type;
1102
1103

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