GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/h264_cavlc.c Lines: 459 509 90.2 %
Date: 2020-04-02 05:41:20 Branches: 348 386 90.2 %

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
286
static av_cold void init_cavlc_level_tab(void){
302
    int suffix_length;
303
    unsigned int i;
304
305
2288
    for(suffix_length=0; suffix_length<7; suffix_length++){
306
514514
        for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
307
512512
            int prefix= LEVEL_TAB_BITS - av_log2(2*i);
308
309
512512
            if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
310
476190
                int level_code = (prefix << suffix_length) +
311
476190
                    (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
312
476190
                int mask = -(level_code&1);
313
476190
                level_code = (((2 + level_code) >> 1) ^ mask) - mask;
314
476190
                cavlc_level_tab[suffix_length][i][0]= level_code;
315
476190
                cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
316
36322
            }else if(prefix + 1 <= LEVEL_TAB_BITS){
317
34320
                cavlc_level_tab[suffix_length][i][0]= prefix+100;
318
34320
                cavlc_level_tab[suffix_length][i][1]= prefix + 1;
319
            }else{
320
2002
                cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
321
2002
                cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
322
            }
323
        }
324
    }
325
286
}
326
327
286
av_cold void ff_h264_decode_init_vlc(void){
328
    static int done = 0;
329
330
286
    if (!done) {
331
        int i;
332
        int offset;
333
286
        done = 1;
334
335
286
        chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
336
286
        chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
337
286
        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
286
        chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
343
286
        chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
344
286
        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
286
        offset = 0;
350
1430
        for(i=0; i<4; i++){
351
1144
            coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
352
1144
            coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
353
1144
            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
1144
            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
286
        av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
365
366
1144
        for(i=0; i<3; i++){
367
858
            chroma_dc_total_zeros_vlc[i+1].table = chroma_dc_total_zeros_vlc_tables[i];
368
858
            chroma_dc_total_zeros_vlc[i+1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
369
858
            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
2288
        for(i=0; i<7; i++){
377
2002
            chroma422_dc_total_zeros_vlc[i+1].table = chroma422_dc_total_zeros_vlc_tables[i];
378
2002
            chroma422_dc_total_zeros_vlc[i+1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
379
2002
            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
4576
        for(i=0; i<15; i++){
387
4290
            total_zeros_vlc[i+1].table = total_zeros_vlc_tables[i];
388
4290
            total_zeros_vlc[i+1].table_allocated = total_zeros_vlc_tables_size;
389
4290
            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
2002
        for(i=0; i<6; i++){
397
1716
            run_vlc[i+1].table = run_vlc_tables[i];
398
1716
            run_vlc[i+1].table_allocated = run_vlc_tables_size;
399
1716
            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
286
        run7_vlc.table = run7_vlc_table,
406
286
        run7_vlc.table_allocated = run7_vlc_table_size;
407
286
        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
286
        init_cavlc_level_tab();
413
    }
414
286
}
415
416
683047
static inline int get_level_prefix(GetBitContext *gb){
417
    unsigned int buf;
418
    int log;
419
420
683047
    OPEN_READER(re, gb);
421
683047
    UPDATE_CACHE(re, gb);
422
683047
    buf=GET_CACHE(re, gb);
423
424
683047
    log= 32 - av_log2(buf);
425
426
683047
    LAST_SKIP_BITS(re, gb, log);
427
683047
    CLOSE_READER(re, gb);
428
429
683047
    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
45088163
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
45088163
    if(max_coeff <= 8){
451
3135112
        if (max_coeff == 4)
452
2556054
            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
3135112
        total_coeff= coeff_token>>2;
456
    }else{
457
41953051
        if(n >= LUMA_DC_BLOCK_INDEX){
458
210603
            total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
459
210603
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
460
210603
            total_coeff= coeff_token>>2;
461
        }else{
462
41742448
            total_coeff= pred_non_zero_count(h, sl, n);
463
41742448
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
464
41742448
            total_coeff= coeff_token>>2;
465
        }
466
    }
467
45088163
    sl->non_zero_count_cache[scan8[n]] = total_coeff;
468
469
    //FIXME set last_non_zero?
470
471
45088163
    if(total_coeff==0)
472
15668411
        return 0;
473
29419752
    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
29419752
    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
29419752
    i = show_bits(gb, 3);
483
29419752
    skip_bits(gb, trailing_ones);
484
29419752
    level[0] = 1-((i&4)>>1);
485
29419752
    level[1] = 1-((i&2)   );
486
29419752
    level[2] = 1-((i&1)<<1);
487
488
29419752
    if(trailing_ones<total_coeff) {
489
        int mask, prefix;
490
13389894
        int suffix_length = total_coeff > 10 & trailing_ones < 3;
491
13389894
        int bitsi= show_bits(gb, LEVEL_TAB_BITS);
492
13389894
        int level_code= cavlc_level_tab[suffix_length][bitsi][0];
493
494
13389894
        skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
495
13389894
        if(level_code >= 100){
496
305379
            prefix= level_code - 100;
497
305379
            if(prefix == LEVEL_TAB_BITS)
498
301644
                prefix += get_level_prefix(gb);
499
500
            //first coefficient has suffix_length equal to 0 or 1
501
305379
            if(prefix<14){ //FIXME try to build a large unified VLC table for all this
502
184421
                if(suffix_length)
503
12209
                    level_code= (prefix<<1) + get_bits1(gb); //part
504
                else
505
172212
                    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
305379
            if(trailing_ones < 3) level_code += 2;
524
525
305379
            suffix_length = 2;
526
305379
            mask= -(level_code&1);
527
305379
            level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
528
        }else{
529
13084515
            level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
530
531
13084515
            suffix_length = 1 + (level_code + 3U > 6U);
532
13084515
            level[trailing_ones]= level_code;
533
        }
534
535
        //remaining coefficients have suffix_length > 0
536
51569106
        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
38179212
            int bitsi= show_bits(gb, LEVEL_TAB_BITS);
539
38179212
            level_code= cavlc_level_tab[suffix_length][bitsi][0];
540
541
38179212
            skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
542
38179212
            if(level_code >= 100){
543
765472
                prefix= level_code - 100;
544
765472
                if(prefix == LEVEL_TAB_BITS){
545
381403
                    prefix += get_level_prefix(gb);
546
                }
547
765472
                if(prefix<15){
548
702286
                    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
765472
                mask= -(level_code&1);
561
765472
                level_code= (((2+level_code)>>1) ^ mask) - mask;
562
            }
563
38179212
            level[i]= level_code;
564
38179212
            suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
565
        }
566
    }
567
568
29419752
    if(total_coeff == max_coeff)
569
291828
        zeros_left=0;
570
    else{
571
29127924
        if (max_coeff <= 8) {
572
1867388
            if (max_coeff == 4)
573
1410006
                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
27260536
            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
29419752
    if (h->pixel_shift) {
618




37564146
        STORE_BLOCK(int32_t)
619
    } else {
620




62415682
        STORE_BLOCK(int16_t)
621
    }
622
623
29419752
    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
29419752
    return 0;
629
}
630
631
static av_always_inline
632
2806644
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
2806644
    int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
639
2806644
    if(IS_INTRA16x16(mb_type)){
640
210603
        AV_ZERO128(sl->mb_luma_dc[p]+0);
641
210603
        AV_ZERO128(sl->mb_luma_dc[p]+8);
642
210603
        AV_ZERO128(sl->mb_luma_dc[p]+16);
643
210603
        AV_ZERO128(sl->mb_luma_dc[p]+24);
644
210603
        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
210603
        if(cbp&15){
651
473030
            for(i8x8=0; i8x8<4; i8x8++){
652
1892120
                for(i4x4=0; i4x4<4; i4x4++){
653
1513696
                    const int index= i4x4 + 4*i8x8 + p*16;
654
1513696
                    if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
655
1513696
                        index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
656
                        return -1;
657
                    }
658
                }
659
            }
660
94606
            return 0xf;
661
        }else{
662
115997
            fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
663
115997
            return 0;
664
        }
665
    }else{
666
2596041
        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
2596041
        int new_cbp = 0;
669
12980205
        for(i8x8=0; i8x8<4; i8x8++){
670
10384164
            if(cbp & (1<<i8x8)){
671
7657176
                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
26684095
                    for(i4x4=0; i4x4<4; i4x4++){
685
21347276
                        const int index= i4x4 + 4*i8x8 + p*16;
686
21347276
                        if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
687
21347276
                                            scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
688
                            return -1;
689
                        }
690
21347276
                        new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
691
                    }
692
                }
693
            }else{
694
2726988
                uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
695
2726988
                nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
696
            }
697
        }
698
2596041
        return new_cbp;
699
    }
700
}
701
702
4346943
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
4346943
    int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
708

4346943
    const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
709
4346943
    const int pixel_shift = h->pixel_shift;
710
711
4346943
    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
4346943
    cbp = 0; /* avoid warning. FIXME: find a solution without slowing
715
                down the code */
716
4346943
    if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
717
3338086
        if (sl->mb_skip_run == -1) {
718
2485391
            unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
719
2485391
            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
2485391
            sl->mb_skip_run = mb_skip_run;
724
        }
725
726
3338086
        if (sl->mb_skip_run--) {
727

855807
            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
855807
            decode_mb_skip(h, sl);
732
855807
            return 0;
733
        }
734
    }
735
3491136
    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
3491136
    sl->prev_mb_skipped = 0;
741
742
3491136
    mb_type= get_ue_golomb(&sl->gb);
743
3491136
    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
2613725
    } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
752
1604868
        if(mb_type < 5){
753
1367646
            partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
754
1367646
            mb_type         = ff_h264_p_mb_type_info[mb_type].type;
755
        }else{
756
237222
            mb_type -= 5;
757
237222
            goto decode_intra_mb;
758
        }
759
    }else{
760
       av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
761

1008857
        if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
762
            mb_type--;
763
1008857
decode_intra_mb:
764
1386978
        if(mb_type > 25){
765
            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
            return -1;
767
        }
768
1386978
        partition_count=0;
769
1386978
        cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
770
1386978
        sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
771
1386978
        mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
772
    }
773
774
3491136
    if (MB_FIELD(sl))
775
981328
        mb_type |= MB_TYPE_INTERLACED;
776
777
3491136
    h->slice_table[mb_xy] = sl->slice_num;
778
779
3491136
    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
3473690
    fill_decode_neighbors(h, sl, mb_type);
801
3473690
    fill_decode_caches(h, sl, mb_type);
802
803
    //mb_pred
804
3473690
    if(IS_INTRA(mb_type)){
805
        int pred_mode;
806
//            init_top_left_availability(h);
807
1369532
        if(IS_INTRA4x4(mb_type)){
808
            int i;
809
1158929
            int di = 1;
810

1158929
            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
13201933
            for(i=0; i<16; i+=di){
817
12043004
                int mode = pred_intra_mode(h, sl, i);
818
819
12043004
                if(!get_bits1(&sl->gb)){
820
6502141
                    const int rem_mode= get_bits(&sl->gb, 3);
821
6502141
                    mode = rem_mode + (rem_mode >= mode);
822
                }
823
824
12043004
                if(di==4)
825
2166620
                    fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
826
                else
827
9876384
                    sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
828
            }
829
1158929
            write_back_intra_pred_mode(h, sl);
830
1158929
            if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
831
1158929
                                                 sl->top_samples_available, sl->left_samples_available) < 0)
832
                return -1;
833
        }else{
834
421206
            sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
835
210603
                                                                     sl->left_samples_available, sl->intra16x16_pred_mode, 0);
836
210603
            if (sl->intra16x16_pred_mode < 0)
837
                return -1;
838
        }
839
1369532
        if(decode_chroma){
840
1342403
            pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
841
1342403
                                                     sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
842
1342403
            if(pred_mode < 0)
843
                return -1;
844
1342403
            sl->chroma_pred_mode = pred_mode;
845
        } else {
846
27129
            sl->chroma_pred_mode = DC_128_PRED8x8;
847
        }
848
2104158
    }else if(partition_count==4){
849
        int i, j, sub_partition_count[4], list, ref[2][4];
850
851
511482
        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
                    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
1667415
            for(i=0; i<4; i++){
871
1333932
                sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
872
1333932
                if(sl->sub_mb_type[i] >=4){
873
                    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
                    return -1;
875
                }
876
1333932
                sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
877
1333932
                sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
878
            }
879
        }
880
881
1200963
        for (list = 0; list < sl->list_count; list++) {
882
689481
            int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
883
3447405
            for(i=0; i<4; i++){
884
2757924
                if(IS_DIRECT(sl->sub_mb_type[i])) continue;
885
2527266
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
886
                    unsigned int tmp;
887
2200238
                    if(ref_count == 1){
888
756033
                        tmp= 0;
889
1444205
                    }else if(ref_count == 2){
890
454436
                        tmp= get_bits1(&sl->gb)^1;
891
                    }else{
892
989769
                        tmp= get_ue_golomb_31(&sl->gb);
893
989769
                        if(tmp>=ref_count){
894
                            av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
895
                            return -1;
896
                        }
897
                    }
898
2200238
                    ref[list][i]= tmp;
899
                }else{
900
                 //FIXME
901
327028
                    ref[list][i] = -1;
902
                }
903
            }
904
        }
905
906
511482
        if(dct8x8_allowed)
907
51527
            dct8x8_allowed = get_dct8x8_allowed(h, sl);
908
909
1200963
        for (list = 0; list < sl->list_count; list++) {
910
3447405
            for(i=0; i<4; i++){
911
2757924
                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
2527266
                sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
916
2527266
                sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
917
918
2527266
                if(IS_DIR(sl->sub_mb_type[i], 0, list)){
919
2200238
                    const int sub_mb_type= sl->sub_mb_type[i];
920
2200238
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
921
5863664
                    for(j=0; j<sub_partition_count[i]; j++){
922
                        int mx, my;
923
3663426
                        const int index= 4*i + block_width*j;
924
3663426
                        int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
925
3663426
                        pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
926
3663426
                        mx += (unsigned)get_se_golomb(&sl->gb);
927
3663426
                        my += (unsigned)get_se_golomb(&sl->gb);
928
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
929
930
3663426
                        if(IS_SUB_8X8(sub_mb_type)){
931
1141536
                            mv_cache[ 1 ][0]=
932
1141536
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
933
1141536
                            mv_cache[ 1 ][1]=
934
1141536
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
935
2521890
                        }else if(IS_SUB_8X4(sub_mb_type)){
936
1024318
                            mv_cache[ 1 ][0]= mx;
937
1024318
                            mv_cache[ 1 ][1]= my;
938
1497572
                        }else if(IS_SUB_4X8(sub_mb_type)){
939
688600
                            mv_cache[ 8 ][0]= mx;
940
688600
                            mv_cache[ 8 ][1]= my;
941
                        }
942
3663426
                        mv_cache[ 0 ][0]= mx;
943
3663426
                        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
1592676
    }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
1471785
        if(IS_16X16(mb_type)){
959
2248906
            for (list = 0; list < sl->list_count; list++) {
960
                    unsigned int val;
961
1254114
                    if(IS_DIR(mb_type, 0, list)){
962
1050560
                        unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
963
1050560
                        if (rc == 1) {
964
550783
                            val= 0;
965
499777
                        } else if (rc == 2) {
966
135504
                            val= get_bits1(&sl->gb)^1;
967
                        }else{
968
364273
                            val= get_ue_golomb_31(&sl->gb);
969
364273
                            if (val >= rc) {
970
                                av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
971
                                return -1;
972
                            }
973
                        }
974
1050560
                    fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
975
                    }
976
            }
977
2248906
            for (list = 0; list < sl->list_count; list++) {
978
1254114
                if(IS_DIR(mb_type, 0, list)){
979
1050560
                    pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
980
1050560
                    mx += (unsigned)get_se_golomb(&sl->gb);
981
1050560
                    my += (unsigned)get_se_golomb(&sl->gb);
982
                    ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
983
984
1050560
                    fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
985
                }
986
            }
987
        }
988
476993
        else if(IS_16X8(mb_type)){
989
603529
            for (list = 0; list < sl->list_count; list++) {
990
1052904
                    for(i=0; i<2; i++){
991
                        unsigned int val;
992
701936
                        if(IS_DIR(mb_type, i, list)){
993
547878
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
994
547878
                            if (rc == 1) {
995
204911
                                val= 0;
996
342967
                            } else if (rc == 2) {
997
80255
                                val= get_bits1(&sl->gb)^1;
998
                            }else{
999
262712
                                val= get_ue_golomb_31(&sl->gb);
1000
262712
                                if (val >= rc) {
1001
                                    av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1002
                                    return -1;
1003
                                }
1004
                            }
1005
                        }else
1006
154058
                            val= LIST_NOT_USED&0xFF;
1007
701936
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
1008
                    }
1009
            }
1010
603529
            for (list = 0; list < sl->list_count; list++) {
1011
1052904
                for(i=0; i<2; i++){
1012
                    unsigned int val;
1013
701936
                    if(IS_DIR(mb_type, i, list)){
1014
547878
                        pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1015
547878
                        mx += (unsigned)get_se_golomb(&sl->gb);
1016
547878
                        my += (unsigned)get_se_golomb(&sl->gb);
1017
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1018
1019
547878
                        val= pack16to32(mx,my);
1020
                    }else
1021
154058
                        val=0;
1022
701936
                    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
528757
            for (list = 0; list < sl->list_count; list++) {
1028
912975
                    for(i=0; i<2; i++){
1029
                        unsigned int val;
1030
608650
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1031
482052
                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
1032
482052
                            if (rc == 1) {
1033
180611
                                val= 0;
1034
301441
                            } else if (rc == 2) {
1035
82740
                                val= get_bits1(&sl->gb)^1;
1036
                            }else{
1037
218701
                                val= get_ue_golomb_31(&sl->gb);
1038
218701
                                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
608650
                        fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1046
                    }
1047
            }
1048
528757
            for (list = 0; list < sl->list_count; list++) {
1049
912975
                for(i=0; i<2; i++){
1050
                    unsigned int val;
1051
608650
                    if(IS_DIR(mb_type, i, list)){
1052
482052
                        pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1053
482052
                        mx += (unsigned)get_se_golomb(&sl->gb);
1054
482052
                        my += (unsigned)get_se_golomb(&sl->gb);
1055
                        ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1056
1057
482052
                        val= pack16to32(mx,my);
1058
                    }else
1059
126598
                        val=0;
1060
608650
                    fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1061
                }
1062
            }
1063
        }
1064
    }
1065
1066
3473690
    if(IS_INTER(mb_type))
1067
2104158
        write_back_motion(h, sl, mb_type);
1068
1069
3473690
    if(!IS_INTRA16x16(mb_type)){
1070
3263087
        cbp= get_ue_golomb(&sl->gb);
1071
1072
3263087
        if(decode_chroma){
1073
3223737
            if(cbp > 47){
1074
                av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1075
                return -1;
1076
            }
1077
3223737
            if (IS_INTRA4x4(mb_type))
1078
1134780
                cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1079
            else
1080
2088957
                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

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

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

6280334
    if(cbp || IS_INTRA16x16(mb_type)){
1104
        int i4x4, i8x8, chroma_idx;
1105
        int dquant;
1106
        int ret;
1107
2806644
        GetBitContext *gb = &sl->gb;
1108
        const uint8_t *scan, *scan8x8;
1109
2806644
        const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1110
1111
2806644
        dquant= get_se_golomb(&sl->gb);
1112
1113
2806644
        sl->qscale += (unsigned)dquant;
1114
1115
2806644
        if (((unsigned)sl->qscale) > max_qp){
1116
8070
            if (sl->qscale < 0) sl->qscale += max_qp + 1;
1117
4210
            else                sl->qscale -= max_qp+1;
1118
8070
            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
2806644
        sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1126
2806644
        sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1127
1128
2806644
        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
1982481
            scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1133
1982481
            scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1134
        }
1135
1136
2806644
        if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1137
            return -1;
1138
        }
1139
2806644
        h->cbp_table[mb_xy] |= ret << 12;
1140
2806644
        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
2806644
            const int num_c8x8 = h->ps.sps->chroma_format_idc;
1149
1150
2806644
            if(cbp&0x30){
1151
4702668
                for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1152
3135112
                    if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1153
                                        CHROMA_DC_BLOCK_INDEX + chroma_idx,
1154
3135112
                                        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
2806644
            if(cbp&0x20){
1161
3019302
                for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1162
2012868
                    const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1163
2012868
                    int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1164
4412880
                    for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1165
12000060
                        for (i4x4 = 0; i4x4 < 4; i4x4++) {
1166
9600048
                            const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1167
9600048
                            if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1168
                                return -1;
1169
9600048
                            mb += 16 << pixel_shift;
1170
                        }
1171
                    }
1172
                }
1173
            }else{
1174
1800210
                fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1175
1800210
                fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1176
            }
1177
        }
1178
    }else{
1179
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1180
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1181
667046
        fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1182
    }
1183
3473690
    h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1184
3473690
    write_back_non_zero_count(h, sl);
1185
1186
3473690
    return 0;
1187
}