h264.c 310 KB
Newer Older
michaelni's avatar
michaelni committed
1 2 3 4
/*
 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
michaelni's avatar
michaelni committed
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
michaelni's avatar
michaelni committed
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
michaelni's avatar
michaelni committed
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * 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
michaelni's avatar
michaelni committed
20
 */
21

michaelni's avatar
michaelni committed
22 23 24 25 26 27 28 29 30
/**
 * @file h264.c
 * H.264 / AVC / MPEG4 part10 codec.
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

#include "dsputil.h"
#include "avcodec.h"
#include "mpegvideo.h"
31
#include "h264.h"
michaelni's avatar
michaelni committed
32
#include "h264data.h"
33
#include "h264_parser.h"
michaelni's avatar
michaelni committed
34
#include "golomb.h"
35
#include "rectangle.h"
michaelni's avatar
michaelni committed
36

37
#include "cabac.h"
38 39 40
#ifdef ARCH_X86
#include "i386/h264_i386.h"
#endif
41

42
//#undef NDEBUG
michaelni's avatar
michaelni committed
43 44
#include <assert.h>

45 46 47 48 49 50
/**
 * Value of Picture.reference when Picture is not a reference picture, but
 * is held for delayed output.
 */
#define DELAYED_PIC_REF 4

michaelni's avatar
michaelni committed
51
static VLC coeff_token_vlc[4];
cehoyos's avatar
cehoyos committed
52 53 54
static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
static const int coeff_token_vlc_tables_size[4]={520,332,280,256};

michaelni's avatar
michaelni committed
55
static VLC chroma_dc_coeff_token_vlc;
cehoyos's avatar
cehoyos committed
56 57
static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
static const int chroma_dc_coeff_token_vlc_table_size = 256;
michaelni's avatar
michaelni committed
58 59

static VLC total_zeros_vlc[15];
cehoyos's avatar
cehoyos committed
60 61 62
static VLC_TYPE total_zeros_vlc_tables[15][512][2];
static const int total_zeros_vlc_tables_size = 512;

michaelni's avatar
michaelni committed
63
static VLC chroma_dc_total_zeros_vlc[3];
cehoyos's avatar
cehoyos committed
64 65
static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
static const int chroma_dc_total_zeros_vlc_tables_size = 8;
michaelni's avatar
michaelni committed
66 67

static VLC run_vlc[6];
cehoyos's avatar
cehoyos committed
68 69 70
static VLC_TYPE run_vlc_tables[6][8][2];
static const int run_vlc_tables_size = 8;

michaelni's avatar
michaelni committed
71
static VLC run7_vlc;
cehoyos's avatar
cehoyos committed
72 73
static VLC_TYPE run7_vlc_table[96][2];
static const int run7_vlc_table_size = 96;
michaelni's avatar
michaelni committed
74

michaelni's avatar
michaelni committed
75 76
static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
77
static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);
78
static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize);
79
static Picture * remove_long(H264Context *h, int i, int ref_mask);
michaelni's avatar
michaelni committed
80

81
static av_always_inline uint32_t pack16to32(int a, int b){
michaelni's avatar
michaelni committed
82 83 84 85 86 87 88
#ifdef WORDS_BIGENDIAN
   return (b&0xFFFF) + (a<<16);
#else
   return (a&0xFFFF) + (b<<16);
#endif
}

89
static const uint8_t rem6[52]={
90 91 92
0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
};

93
static const uint8_t div6[52]={
94 95 96
0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
};

97 98 99 100 101 102
static const int left_block_options[4][8]={
    {0,1,2,3,7,10,8,11},
    {2,2,3,3,8,11,8,11},
    {0,0,1,1,7,10,7,10},
    {0,2,0,2,7,10,7,10}
};
103

lorenm's avatar
lorenm committed
104
static void fill_caches(H264Context *h, int mb_type, int for_deblock){
michaelni's avatar
michaelni committed
105
    MpegEncContext * const s = &h->s;
106
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
107 108
    int topleft_xy, top_xy, topright_xy, left_xy[2];
    int topleft_type, top_type, topright_type, left_type[2];
109
    const int * left_block;
lorenm's avatar
lorenm committed
110
    int topleft_partition= -1;
michaelni's avatar
michaelni committed
111 112
    int i;

113 114
    top_xy     = mb_xy  - (s->mb_stride << FIELD_PICTURE);

lorenm's avatar
lorenm committed
115
    //FIXME deblocking could skip the intra and nnz parts.
116
    if(for_deblock && (h->slice_num == 1 || h->slice_table[mb_xy] == h->slice_table[top_xy]) && !FRAME_MBAFF)
117 118
        return;

diego's avatar
diego committed
119 120
    /* Wow, what a mess, why didn't they simplify the interlacing & intra
     * stuff, I can't imagine that these complex rules are worth it. */
121

122 123 124
    topleft_xy = top_xy - 1;
    topright_xy= top_xy + 1;
    left_xy[1] = left_xy[0] = mb_xy-1;
125
    left_block = left_block_options[0];
lorenm's avatar
lorenm committed
126
    if(FRAME_MBAFF){
127 128 129 130 131 132 133 134 135 136
        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
        const int top_pair_xy      = pair_xy     - s->mb_stride;
        const int topleft_pair_xy  = top_pair_xy - 1;
        const int topright_pair_xy = top_pair_xy + 1;
        const int topleft_mb_frame_flag  = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
        const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
        const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
        const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
        const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
        const int bottom = (s->mb_y & 1);
mbardiaux's avatar
mbardiaux committed
137
        tprintf(s->avctx, "fill_caches: curr_mb_frame_flag:%d, left_mb_frame_flag:%d, topleft_mb_frame_flag:%d, top_mb_frame_flag:%d, topright_mb_frame_flag:%d\n", curr_mb_frame_flag, left_mb_frame_flag, topleft_mb_frame_flag, top_mb_frame_flag, topright_mb_frame_flag);
138 139 140 141 142 143 144 145 146 147 148
        if (bottom
                ? !curr_mb_frame_flag // bottom macroblock
                : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
                ) {
            top_xy -= s->mb_stride;
        }
        if (bottom
                ? !curr_mb_frame_flag // bottom macroblock
                : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
                ) {
            topleft_xy -= s->mb_stride;
lorenm's avatar
lorenm committed
149 150
        } else if(bottom && curr_mb_frame_flag && !left_mb_frame_flag) {
            topleft_xy += s->mb_stride;
diego's avatar
diego committed
151
            // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition
lorenm's avatar
lorenm committed
152
            topleft_partition = 0;
153 154 155 156 157 158 159 160 161 162 163
        }
        if (bottom
                ? !curr_mb_frame_flag // bottom macroblock
                : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
                ) {
            topright_xy -= s->mb_stride;
        }
        if (left_mb_frame_flag != curr_mb_frame_flag) {
            left_xy[1] = left_xy[0] = pair_xy - 1;
            if (curr_mb_frame_flag) {
                if (bottom) {
164
                    left_block = left_block_options[1];
165
                } else {
166
                    left_block= left_block_options[2];
167 168 169
                }
            } else {
                left_xy[1] += s->mb_stride;
170
                left_block = left_block_options[3];
171 172
            }
        }
michaelni's avatar
michaelni committed
173 174
    }

175 176 177
    h->top_mb_xy = top_xy;
    h->left_mb_xy[0] = left_xy[0];
    h->left_mb_xy[1] = left_xy[1];
michael's avatar
michael committed
178
    if(for_deblock){
lorenm's avatar
lorenm committed
179 180
        topleft_type = 0;
        topright_type = 0;
181 182 183
        top_type     = h->slice_table[top_xy     ] < 0xFFFF ? s->current_picture.mb_type[top_xy]     : 0;
        left_type[0] = h->slice_table[left_xy[0] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[0]] : 0;
        left_type[1] = h->slice_table[left_xy[1] ] < 0xFFFF ? s->current_picture.mb_type[left_xy[1]] : 0;
lorenm's avatar
lorenm committed
184

185
        if(MB_MBAFF && !IS_INTRA(mb_type)){
lorenm's avatar
lorenm committed
186
            int list;
187
            for(list=0; list<h->list_count; list++){
188 189 190
                //These values where changed for ease of performing MC, we need to change them back
                //FIXME maybe we can make MC and loop filter use the same values or prevent
                //the MC code from changing ref_cache and rather use a temporary array.
lorenm's avatar
lorenm committed
191
                if(USES_LIST(mb_type,list)){
mru's avatar
mru committed
192
                    int8_t *ref = &s->current_picture.ref_index[list][h->mb2b8_xy[mb_xy]];
lorenm's avatar
lorenm committed
193
                    *(uint32_t*)&h->ref_cache[list][scan8[ 0]] =
194
                    *(uint32_t*)&h->ref_cache[list][scan8[ 2]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;
lorenm's avatar
lorenm committed
195 196
                    ref += h->b8_stride;
                    *(uint32_t*)&h->ref_cache[list][scan8[ 8]] =
197
                    *(uint32_t*)&h->ref_cache[list][scan8[10]] = (pack16to32(ref[0],ref[1])&0x00FF00FF)*0x0101;
lorenm's avatar
lorenm committed
198 199 200
                }
            }
        }
michael's avatar
michael committed
201 202 203 204 205 206
    }else{
        topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
        top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;
        topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
        left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
        left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
michaelni's avatar
michaelni committed
207 208

    if(IS_INTRA(mb_type)){
209
        int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
210 211
        h->topleft_samples_available=
        h->top_samples_available=
michaelni's avatar
michaelni committed
212 213 214
        h->left_samples_available= 0xFFFF;
        h->topright_samples_available= 0xEEEA;

215
        if(!(top_type & type_mask)){
michaelni's avatar
michaelni committed
216 217 218 219
            h->topleft_samples_available= 0xB3FF;
            h->top_samples_available= 0x33FF;
            h->topright_samples_available= 0x26EA;
        }
220 221
        if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){
            if(IS_INTERLACED(mb_type)){
222
                if(!(left_type[0] & type_mask)){
223 224 225
                    h->topleft_samples_available&= 0xDFFF;
                    h->left_samples_available&= 0x5FFF;
                }
226
                if(!(left_type[1] & type_mask)){
227 228 229 230 231 232 233
                    h->topleft_samples_available&= 0xFF5F;
                    h->left_samples_available&= 0xFF5F;
                }
            }else{
                int left_typei = h->slice_table[left_xy[0] + s->mb_stride ] == h->slice_num
                                ? s->current_picture.mb_type[left_xy[0] + s->mb_stride] : 0;
                assert(left_xy[0] == left_xy[1]);
234
                if(!((left_typei & type_mask) && (left_type[0] & type_mask))){
235 236 237 238 239
                    h->topleft_samples_available&= 0xDF5F;
                    h->left_samples_available&= 0x5F5F;
                }
            }
        }else{
240
            if(!(left_type[0] & type_mask)){
michaelni's avatar
michaelni committed
241 242 243 244
                h->topleft_samples_available&= 0xDF5F;
                h->left_samples_available&= 0x5F5F;
            }
        }
245

246
        if(!(topleft_type & type_mask))
michaelni's avatar
michaelni committed
247
            h->topleft_samples_available&= 0x7FFF;
248

249
        if(!(topright_type & type_mask))
michaelni's avatar
michaelni committed
250
            h->topright_samples_available&= 0xFBFF;
251

michaelni's avatar
michaelni committed
252 253 254 255 256 257 258 259
        if(IS_INTRA4x4(mb_type)){
            if(IS_INTRA4x4(top_type)){
                h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
                h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
                h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
                h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
            }else{
                int pred;
260
                if(!(top_type & type_mask))
michaelni's avatar
michaelni committed
261
                    pred= -1;
262 263
                else{
                    pred= 2;
michaelni's avatar
michaelni committed
264 265 266 267 268 269 270 271 272 273 274 275
                }
                h->intra4x4_pred_mode_cache[4+8*0]=
                h->intra4x4_pred_mode_cache[5+8*0]=
                h->intra4x4_pred_mode_cache[6+8*0]=
                h->intra4x4_pred_mode_cache[7+8*0]= pred;
            }
            for(i=0; i<2; i++){
                if(IS_INTRA4x4(left_type[i])){
                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
                }else{
                    int pred;
276
                    if(!(left_type[i] & type_mask))
michaelni's avatar
michaelni committed
277
                        pred= -1;
278 279
                    else{
                        pred= 2;
michaelni's avatar
michaelni committed
280 281 282 283 284 285 286
                    }
                    h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
                    h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
                }
            }
        }
    }
287
    }
288 289


michaelni's avatar
michaelni committed
290
/*
291 292 293 294 295 296
0 . T T. T T T T
1 L . .L . . . .
2 L . .L . . . .
3 . T TL . . . .
4 L . .L . . . .
5 L . .. . . . .
michaelni's avatar
michaelni committed
297
*/
diego's avatar
diego committed
298
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
michaelni's avatar
michaelni committed
299
    if(top_type){
300 301 302
        h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
        h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
        h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
303
        h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
304

305
        h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
306
        h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
307

308
        h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
309
        h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
310

michaelni's avatar
michaelni committed
311
    }else{
312
        h->non_zero_count_cache[4+8*0]=
michaelni's avatar
michaelni committed
313 314 315
        h->non_zero_count_cache[5+8*0]=
        h->non_zero_count_cache[6+8*0]=
        h->non_zero_count_cache[7+8*0]=
316

michaelni's avatar
michaelni committed
317 318
        h->non_zero_count_cache[1+8*0]=
        h->non_zero_count_cache[2+8*0]=
319

michaelni's avatar
michaelni committed
320
        h->non_zero_count_cache[1+8*3]=
michael's avatar
michael committed
321
        h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
322

michaelni's avatar
michaelni committed
323
    }
324

325 326 327 328 329 330 331
    for (i=0; i<2; i++) {
        if(left_type[i]){
            h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
            h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
            h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
            h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
        }else{
332 333 334
            h->non_zero_count_cache[3+8*1 + 2*8*i]=
            h->non_zero_count_cache[3+8*2 + 2*8*i]=
            h->non_zero_count_cache[0+8*1 +   8*i]=
335
            h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
        }
    }

    if( h->pps.cabac ) {
        // top_cbp
        if(top_type) {
            h->top_cbp = h->cbp_table[top_xy];
        } else if(IS_INTRA(mb_type)) {
            h->top_cbp = 0x1C0;
        } else {
            h->top_cbp = 0;
        }
        // left_cbp
        if (left_type[0]) {
            h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
        } else if(IS_INTRA(mb_type)) {
            h->left_cbp = 0x1C0;
        } else {
            h->left_cbp = 0;
        }
        if (left_type[0]) {
            h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
        }
        if (left_type[1]) {
            h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
361
        }
michaelni's avatar
michaelni committed
362
    }
363

michaelni's avatar
michaelni committed
364
#if 1
365
    if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
michaelni's avatar
michaelni committed
366
        int list;
367
        for(list=0; list<h->list_count; list++){
368
            if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
michaelni's avatar
michaelni committed
369 370 371 372 373
                /*if(!h->mv_cache_clean[list]){
                    memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
                    memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
                    h->mv_cache_clean[list]= 1;
                }*/
374
                continue;
michaelni's avatar
michaelni committed
375 376
            }
            h->mv_cache_clean[list]= 0;
377

378
            if(USES_LIST(top_type, list)){
michaelni's avatar
michaelni committed
379 380 381 382 383 384 385 386 387 388 389
                const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
                const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
                *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
                *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
                *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
                *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
                h->ref_cache[list][scan8[0] + 0 - 1*8]=
                h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
                h->ref_cache[list][scan8[0] + 2 - 1*8]=
                h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
            }else{
390 391 392
                *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
                *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
                *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
michaelni's avatar
michaelni committed
393 394 395 396
                *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
                *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
            }

lorenm's avatar
lorenm committed
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
            for(i=0; i<2; i++){
                int cache_idx = scan8[0] - 1 + i*2*8;
                if(USES_LIST(left_type[i], list)){
                    const int b_xy= h->mb2b_xy[left_xy[i]] + 3;
                    const int b8_xy= h->mb2b8_xy[left_xy[i]] + 1;
                    *(uint32_t*)h->mv_cache[list][cache_idx  ]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]];
                    *(uint32_t*)h->mv_cache[list][cache_idx+8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]];
                    h->ref_cache[list][cache_idx  ]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0+i*2]>>1)];
                    h->ref_cache[list][cache_idx+8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[1+i*2]>>1)];
                }else{
                    *(uint32_t*)h->mv_cache [list][cache_idx  ]=
                    *(uint32_t*)h->mv_cache [list][cache_idx+8]= 0;
                    h->ref_cache[list][cache_idx  ]=
                    h->ref_cache[list][cache_idx+8]= left_type[i] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
                }
michaelni's avatar
michaelni committed
412 413
            }

414
            if(for_deblock || ((IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred) && !FRAME_MBAFF))
michael's avatar
michael committed
415 416
                continue;

417
            if(USES_LIST(topleft_type, list)){
lorenm's avatar
lorenm committed
418 419
                const int b_xy = h->mb2b_xy[topleft_xy] + 3 + h->b_stride + (topleft_partition & 2*h->b_stride);
                const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (topleft_partition & h->b8_stride);
420 421 422 423 424 425
                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
                h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
            }else{
                *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
                h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
            }
426

427
            if(USES_LIST(topright_type, list)){
428 429 430 431 432 433 434 435 436
                const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
                const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
                *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
                h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
            }else{
                *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
                h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
            }

lorenm's avatar
lorenm committed
437
            if((IS_SKIP(mb_type) || IS_DIRECT(mb_type)) && !FRAME_MBAFF)
lorenm's avatar
lorenm committed
438
                continue;
439 440 441

            h->ref_cache[list][scan8[5 ]+1] =
            h->ref_cache[list][scan8[7 ]+1] =
442
            h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)
443
            h->ref_cache[list][scan8[4 ]] =
michaelni's avatar
michaelni committed
444 445 446
            h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
            *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
            *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
447
            *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
michaelni's avatar
michaelni committed
448 449
            *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
            *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
450 451 452

            if( h->pps.cabac ) {
                /* XXX beurk, Load mvd */
453
                if(USES_LIST(top_type, list)){
454 455 456 457 458 459
                    const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
                    *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
                }else{
460 461 462
                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
463 464
                    *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
                }
465
                if(USES_LIST(left_type[0], list)){
466 467 468 469 470 471 472
                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[0]];
                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[1]];
                }else{
                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
                }
473
                if(USES_LIST(left_type[1], list)){
474 475 476 477 478 479 480 481 482
                    const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[2]];
                    *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)h->mvd_table[list][b_xy + h->b_stride*left_block[3]];
                }else{
                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
                    *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
                }
                *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
                *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
483
                *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
484 485
                *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
                *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
486

487
                if(h->slice_type_nos == FF_B_TYPE){
488 489 490 491 492 493 494 495 496 497 498
                    fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);

                    if(IS_DIRECT(top_type)){
                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
                    }else if(IS_8X8(top_type)){
                        int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
                        h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
                        h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
                    }else{
                        *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
                    }
499

lorenm's avatar
lorenm committed
500 501 502 503 504 505 506 507
                    if(IS_DIRECT(left_type[0]))
                        h->direct_cache[scan8[0] - 1 + 0*8]= 1;
                    else if(IS_8X8(left_type[0]))
                        h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[h->mb2b8_xy[left_xy[0]] + 1 + h->b8_stride*(left_block[0]>>1)];
                    else
                        h->direct_cache[scan8[0] - 1 + 0*8]= 0;

                    if(IS_DIRECT(left_type[1]))
508
                        h->direct_cache[scan8[0] - 1 + 2*8]= 1;
lorenm's avatar
lorenm committed
509 510 511
                    else if(IS_8X8(left_type[1]))
                        h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[h->mb2b8_xy[left_xy[1]] + 1 + h->b8_stride*(left_block[2]>>1)];
                    else
512
                        h->direct_cache[scan8[0] - 1 + 2*8]= 0;
lorenm's avatar
lorenm committed
513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
                }
            }

            if(FRAME_MBAFF){
#define MAP_MVS\
                    MAP_F2F(scan8[0] - 1 - 1*8, topleft_type)\
                    MAP_F2F(scan8[0] + 0 - 1*8, top_type)\
                    MAP_F2F(scan8[0] + 1 - 1*8, top_type)\
                    MAP_F2F(scan8[0] + 2 - 1*8, top_type)\
                    MAP_F2F(scan8[0] + 3 - 1*8, top_type)\
                    MAP_F2F(scan8[0] + 4 - 1*8, topright_type)\
                    MAP_F2F(scan8[0] - 1 + 0*8, left_type[0])\
                    MAP_F2F(scan8[0] - 1 + 1*8, left_type[0])\
                    MAP_F2F(scan8[0] - 1 + 2*8, left_type[1])\
                    MAP_F2F(scan8[0] - 1 + 3*8, left_type[1])
                if(MB_FIELD){
#define MAP_F2F(idx, mb_type)\
                    if(!IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
                        h->ref_cache[list][idx] <<= 1;\
                        h->mv_cache[list][idx][1] /= 2;\
                        h->mvd_cache[list][idx][1] /= 2;\
                    }
                    MAP_MVS
#undef MAP_F2F
                }else{
#define MAP_F2F(idx, mb_type)\
                    if(IS_INTERLACED(mb_type) && h->ref_cache[list][idx] >= 0){\
                        h->ref_cache[list][idx] >>= 1;\
                        h->mv_cache[list][idx][1] <<= 1;\
                        h->mvd_cache[list][idx][1] <<= 1;\
543
                    }
lorenm's avatar
lorenm committed
544 545
                    MAP_MVS
#undef MAP_F2F
546
                }
547
            }
michaelni's avatar
michaelni committed
548 549 550
        }
    }
#endif
lorenm's avatar
lorenm committed
551 552

    h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
michaelni's avatar
michaelni committed
553 554 555
}

static inline void write_back_intra_pred_mode(H264Context *h){
556
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

    h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
    h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
    h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
    h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
    h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
    h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
    h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
}

/**
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 */
static inline int check_intra4x4_pred_mode(H264Context *h){
    MpegEncContext * const s = &h->s;
    static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
    static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
    int i;
575

michaelni's avatar
michaelni committed
576 577 578 579
    if(!(h->top_samples_available&0x8000)){
        for(i=0; i<4; i++){
            int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
            if(status<0){
580
                av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
581 582 583 584 585 586
                return -1;
            } else if(status){
                h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
            }
        }
    }
587

588 589
    if((h->left_samples_available&0x8888)!=0x8888){
        static const int mask[4]={0x8000,0x2000,0x80,0x20};
michaelni's avatar
michaelni committed
590
        for(i=0; i<4; i++){
591
            if(!(h->left_samples_available&mask[i])){
michaelni's avatar
michaelni committed
592 593
            int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
            if(status<0){
594
                av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
595 596 597 598
                return -1;
            } else if(status){
                h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
            }
599
            }
michaelni's avatar
michaelni committed
600 601 602 603 604 605 606 607 608 609 610 611 612
        }
    }

    return 0;
} //FIXME cleanup like next

/**
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 */
static inline int check_intra_pred_mode(H264Context *h, int mode){
    MpegEncContext * const s = &h->s;
    static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
    static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
613

michael's avatar
michael committed
614
    if(mode > 6U) {
michael's avatar
michael committed
615
        av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y);
michael's avatar
michael committed
616
        return -1;
michael's avatar
michael committed
617
    }
618

michaelni's avatar
michaelni committed
619 620 621
    if(!(h->top_samples_available&0x8000)){
        mode= top[ mode ];
        if(mode<0){
622
            av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
623 624 625
            return -1;
        }
    }
626

627
    if((h->left_samples_available&0x8080) != 0x8080){
michaelni's avatar
michaelni committed
628
        mode= left[ mode ];
629 630 631
        if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
            mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
        }
michaelni's avatar
michaelni committed
632
        if(mode<0){
633
            av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
634
            return -1;
635
        }
michaelni's avatar
michaelni committed
636 637 638 639 640 641 642 643 644 645 646 647 648 649
    }

    return mode;
}

/**
 * gets the predicted intra4x4 prediction mode.
 */
static inline int pred_intra_mode(H264Context *h, int n){
    const int index8= scan8[n];
    const int left= h->intra4x4_pred_mode_cache[index8 - 1];
    const int top = h->intra4x4_pred_mode_cache[index8 - 8];
    const int min= FFMIN(left, top);

mbardiaux's avatar
mbardiaux committed
650
    tprintf(h->s.avctx, "mode:%d %d min:%d\n", left ,top, min);
michaelni's avatar
michaelni committed
651 652 653 654 655 656

    if(min<0) return DC_PRED;
    else      return min;
}

static inline void write_back_non_zero_count(H264Context *h){
657
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
658

659 660 661
    h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
    h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
    h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
662
    h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
663 664 665
    h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
    h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
    h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
666

667
    h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
668
    h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
669
    h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
670

671
    h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
672
    h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
673
    h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
michaelni's avatar
michaelni committed
674 675 676
}

/**
diego's avatar
diego committed
677
 * gets the predicted number of non-zero coefficients.
michaelni's avatar
michaelni committed
678 679 680 681 682 683 684
 * @param n block index
 */
static inline int pred_non_zero_count(H264Context *h, int n){
    const int index8= scan8[n];
    const int left= h->non_zero_count_cache[index8 - 1];
    const int top = h->non_zero_count_cache[index8 - 8];
    int i= left + top;
685

michaelni's avatar
michaelni committed
686 687
    if(i<64) i= (i+1)>>1;

mbardiaux's avatar
mbardiaux committed
688
    tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
michaelni's avatar
michaelni committed
689 690 691 692

    return i&31;
}

693 694
static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
    const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
mbardiaux's avatar
mbardiaux committed
695
    MpegEncContext *s = &h->s;
696

lorenm's avatar
lorenm committed
697 698 699
    /* there is no consistent mapping of mvs to neighboring locations that will
     * make mbaff happy, so we can't move all this logic to fill_caches */
    if(FRAME_MBAFF){
mru's avatar
mru committed
700
        const uint32_t *mb_types = s->current_picture_ptr->mb_type;
lorenm's avatar
lorenm committed
701 702 703 704 705 706 707 708 709 710 711
        const int16_t *mv;
        *(uint32_t*)h->mv_cache[list][scan8[0]-2] = 0;
        *C = h->mv_cache[list][scan8[0]-2];

        if(!MB_FIELD
           && (s->mb_y&1) && i < scan8[0]+8 && topright_ref != PART_NOT_AVAILABLE){
            int topright_xy = s->mb_x + (s->mb_y-1)*s->mb_stride + (i == scan8[0]+3);
            if(IS_INTERLACED(mb_types[topright_xy])){
#define SET_DIAG_MV(MV_OP, REF_OP, X4, Y4)\
                const int x4 = X4, y4 = Y4;\
                const int mb_type = mb_types[(x4>>2)+(y4>>2)*s->mb_stride];\
lorenm's avatar
lorenm committed
712
                if(!USES_LIST(mb_type,list))\
lorenm's avatar
lorenm committed
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
                    return LIST_NOT_USED;\
                mv = s->current_picture_ptr->motion_val[list][x4 + y4*h->b_stride];\
                h->mv_cache[list][scan8[0]-2][0] = mv[0];\
                h->mv_cache[list][scan8[0]-2][1] = mv[1] MV_OP;\
                return s->current_picture_ptr->ref_index[list][(x4>>1) + (y4>>1)*h->b8_stride] REF_OP;

                SET_DIAG_MV(*2, >>1, s->mb_x*4+(i&7)-4+part_width, s->mb_y*4-1);
            }
        }
        if(topright_ref == PART_NOT_AVAILABLE
           && ((s->mb_y&1) || i >= scan8[0]+8) && (i&7)==4
           && h->ref_cache[list][scan8[0]-1] != PART_NOT_AVAILABLE){
            if(!MB_FIELD
               && IS_INTERLACED(mb_types[h->left_mb_xy[0]])){
                SET_DIAG_MV(*2, >>1, s->mb_x*4-1, (s->mb_y|1)*4+(s->mb_y&1)*2+(i>>4)-1);
            }
            if(MB_FIELD
               && !IS_INTERLACED(mb_types[h->left_mb_xy[0]])
               && i >= scan8[0]+8){
diego's avatar
diego committed
732
                // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
lorenm's avatar
lorenm committed
733
                SET_DIAG_MV(/2, <<1, s->mb_x*4-1, (s->mb_y&~1)*4 - 1 + ((i-scan8[0])>>3)*2);
lorenm's avatar
lorenm committed
734 735 736 737 738
            }
        }
#undef SET_DIAG_MV
    }

739 740 741 742
    if(topright_ref != PART_NOT_AVAILABLE){
        *C= h->mv_cache[list][ i - 8 + part_width ];
        return topright_ref;
    }else{
mbardiaux's avatar
mbardiaux committed
743
        tprintf(s->avctx, "topright MV not available\n");
744

745 746 747 748 749
        *C= h->mv_cache[list][ i - 8 - 1 ];
        return h->ref_cache[list][ i - 8 - 1 ];
    }
}

michaelni's avatar
michaelni committed
750 751 752 753 754 755 756 757 758 759 760 761 762
/**
 * gets the predicted MV.
 * @param n the block index
 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
 * @param mx the x component of the predicted motion vector
 * @param my the y component of the predicted motion vector
 */
static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
    const int index8= scan8[n];
    const int top_ref=      h->ref_cache[list][ index8 - 8 ];
    const int left_ref=     h->ref_cache[list][ index8 - 1 ];
    const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
    const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
763 764 765
    const int16_t * C;
    int diagonal_ref, match_count;

michaelni's avatar
michaelni committed
766
    assert(part_width==1 || part_width==2 || part_width==4);
767

michaelni's avatar
michaelni committed
768
/* mv_cache
769
  B . . A T T T T
michaelni's avatar
michaelni committed
770 771 772 773 774
  U . . L . . , .
  U . . L . . . .
  U . . L . . , .
  . . . L . . . .
*/
775 776 777

    diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
    match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
mbardiaux's avatar
mbardiaux committed
778
    tprintf(h->s.avctx, "pred_motion match_count=%d\n", match_count);
779 780 781 782 783 784
    if(match_count > 1){ //most common
        *mx= mid_pred(A[0], B[0], C[0]);
        *my= mid_pred(A[1], B[1], C[1]);
    }else if(match_count==1){
        if(left_ref==ref){
            *mx= A[0];
785
            *my= A[1];
786 787
        }else if(top_ref==ref){
            *mx= B[0];
788
            *my= B[1];
michaelni's avatar
michaelni committed
789
        }else{
790
            *mx= C[0];
791
            *my= C[1];
michaelni's avatar
michaelni committed
792 793
        }
    }else{
794
        if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
michaelni's avatar
michaelni committed
795
            *mx= A[0];
796
            *my= A[1];
michaelni's avatar
michaelni committed
797
        }else{
798 799
            *mx= mid_pred(A[0], B[0], C[0]);
            *my= mid_pred(A[1], B[1], C[1]);
michaelni's avatar
michaelni committed
800 801
        }
    }
802

mbardiaux's avatar
mbardiaux committed
803
    tprintf(h->s.avctx, "pred_motion (%2d %2d %2d) (%2d %2d %2d) (%2d %2d %2d) -> (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1],                    diagonal_ref, C[0], C[1], left_ref, A[0], A[1], ref, *mx, *my, h->s.mb_x, h->s.mb_y, n, list);
michaelni's avatar
michaelni committed
804 805 806 807 808 809 810 811 812 813 814 815 816
}

/**
 * gets the directionally predicted 16x8 MV.
 * @param n the block index
 * @param mx the x component of the predicted motion vector
 * @param my the y component of the predicted motion vector
 */
static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
    if(n==0){
        const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];
        const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];

mbardiaux's avatar
mbardiaux committed
817
        tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", top_ref, B[0], B[1], h->s.mb_x, h->s.mb_y, n, list);
818

michaelni's avatar
michaelni committed
819 820 821 822 823 824 825 826
        if(top_ref == ref){
            *mx= B[0];
            *my= B[1];
            return;
        }
    }else{
        const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];
        const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
827

mbardiaux's avatar
mbardiaux committed
828
        tprintf(h->s.avctx, "pred_16x8: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);
michaelni's avatar
michaelni committed
829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850

        if(left_ref == ref){
            *mx= A[0];
            *my= A[1];
            return;
        }
    }

    //RARE
    pred_motion(h, n, 4, list, ref, mx, my);
}

/**
 * gets the directionally predicted 8x16 MV.
 * @param n the block index
 * @param mx the x component of the predicted motion vector
 * @param my the y component of the predicted motion vector
 */
static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
    if(n==0){
        const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];
        const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];
851

mbardiaux's avatar
mbardiaux committed
852
        tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", left_ref, A[0], A[1], h->s.mb_x, h->s.mb_y, n, list);
michaelni's avatar
michaelni committed
853 854 855 856 857 858 859

        if(left_ref == ref){
            *mx= A[0];
            *my= A[1];
            return;
        }
    }else{
860 861 862 863
        const int16_t * C;
        int diagonal_ref;

        diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
864

mbardiaux's avatar
mbardiaux committed
865
        tprintf(h->s.avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", diagonal_ref, C[0], C[1], h->s.mb_x, h->s.mb_y, n, list);
michaelni's avatar
michaelni committed
866

867
        if(diagonal_ref == ref){
michaelni's avatar
michaelni committed
868 869 870 871 872 873 874 875 876 877 878 879 880 881
            *mx= C[0];
            *my= C[1];
            return;
        }
    }

    //RARE
    pred_motion(h, n, 2, list, ref, mx, my);
}

static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
    const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
    const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];

mbardiaux's avatar
mbardiaux committed
882
    tprintf(h->s.avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
michaelni's avatar
michaelni committed
883 884 885 886

    if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
       || (top_ref == 0  && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
       || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
887

michaelni's avatar
michaelni committed
888 889 890
        *mx = *my = 0;
        return;
    }
891

michaelni's avatar
michaelni committed
892 893 894 895 896
    pred_motion(h, 0, 4, 0, 0, mx, my);

    return;
}

897 898 899 900 901 902 903 904 905 906 907 908
static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){
    int poc0 = h->ref_list[0][i].poc;
    int td = av_clip(poc1 - poc0, -128, 127);
    if(td == 0 || h->ref_list[0][i].long_ref){
        return 256;
    }else{
        int tb = av_clip(poc - poc0, -128, 127);
        int tx = (16384 + (FFABS(td) >> 1)) / td;
        return av_clip((tb*tx + 32) >> 6, -1024, 1023);
    }
}

909
static inline void direct_dist_scale_factor(H264Context * const h){
910 911
    MpegEncContext * const s = &h->s;
    const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
912
    const int poc1 = h->ref_list[1][0].poc;
913 914 915 916 917 918
    int i, field;
    for(field=0; field<2; field++){
        const int poc  = h->s.current_picture_ptr->field_poc[field];
        const int poc1 = h->ref_list[1][0].field_poc[field];
        for(i=0; i < 2*h->ref_count[0]; i++)
            h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16);
919
    }
920 921 922

    for(i=0; i<h->ref_count[0]; i++){
        h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i);
lorenm's avatar
lorenm committed
923
    }
924
}
925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958

static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){
    MpegEncContext * const s = &h->s;
    Picture * const ref1 = &h->ref_list[1][0];
    int j, old_ref, rfield;
    int start= mbafi ? 16                      : 0;
    int end  = mbafi ? 16+2*h->ref_count[list] : h->ref_count[list];
    int interl= mbafi || s->picture_structure != PICT_FRAME;

    /* bogus; fills in for missing frames */
    memset(map[list], 0, sizeof(map[list]));

    for(rfield=0; rfield<2; rfield++){
        for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){
            int poc = ref1->ref_poc[colfield][list][old_ref];

            if     (!interl)
                poc |= 3;
            else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed
                poc= (poc&~3) + rfield + 1;

            for(j=start; j<end; j++){
                if(4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3) == poc){
                    int cur_ref= mbafi ? (j-16)^field : j;
                    map[list][2*old_ref + (rfield^field) + 16] = cur_ref;
                    if(rfield == field)
                        map[list][old_ref] = cur_ref;
                    break;
                }
            }
        }
    }
}

959 960 961 962
static inline void direct_ref_list_init(H264Context * const h){
    MpegEncContext * const s = &h->s;
    Picture * const ref1 = &h->ref_list[1][0];
    Picture * const cur = s->current_picture_ptr;
diego's avatar
diego committed
963
    int list, j, field;
964 965
    int sidx= (s->picture_structure&1)^1;
    int ref1sidx= (ref1->reference&1)^1;
michael's avatar
michael committed
966

967
    for(list=0; list<2; list++){
968
        cur->ref_count[sidx][list] = h->ref_count[list];
969
        for(j=0; j<h->ref_count[list]; j++)
970
            cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3);
971
    }
michael's avatar
michael committed
972

973
    if(s->picture_structure == PICT_FRAME){
974 975
        memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));
        memcpy(cur->ref_poc  [1], cur->ref_poc  [0], sizeof(cur->ref_poc  [0]));
976
    }
michael's avatar
michael committed
977

978
    cur->mbaff= FRAME_MBAFF;
michael's avatar
michael committed
979

980
    if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)
981
        return;
michael's avatar
michael committed
982

983
    for(list=0; list<2; list++){
984 985 986
        fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);
        for(field=0; field<2; field++)
            fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);
987 988
    }
}
989 990 991

static inline void pred_direct_motion(H264Context * const h, int *mb_type){
    MpegEncContext * const s = &h->s;
992 993 994 995 996 997
    int b8_stride = h->b8_stride;
    int b4_stride = h->b_stride;
    int mb_xy = h->mb_xy;
    int mb_type_col[2];
    const int16_t (*l1mv0)[2], (*l1mv1)[2];
    const int8_t *l1ref0, *l1ref1;
998
    const int is_b8x8 = IS_8X8(*mb_type);
999
    unsigned int sub_mb_type;
1000 1001
    int i8, i4;

lorenm's avatar
lorenm committed
1002
#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)
1003 1004

    if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
1005
        if(!IS_INTERLACED(*mb_type)){                    //     AFR/FR    -> AFL/FL
michael's avatar
michael committed
1006 1007 1008 1009 1010
            int cur_poc = s->current_picture_ptr->poc;
            int *col_poc = h->ref_list[1]->field_poc;
            int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);
            mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;
            b8_stride = 0;
1011
        }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
            int fieldoff= 2*(h->ref_list[1][0].reference)-3;
            mb_xy += s->mb_stride*fieldoff;
        }
        goto single_col;
    }else{                                               // AFL/AFR/FR/FL -> AFR/FR
        if(IS_INTERLACED(*mb_type)){                     // AFL       /FL -> AFR/FR
            mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride;
            mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy];
            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
            b8_stride *= 3;
            b4_stride *= 6;
            //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag
            if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)
                && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)
                && !is_b8x8){
                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */
            }else{
                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
            }
        }else{                                           //     AFR/FR    -> AFR/FR
single_col:
            mb_type_col[0] =
            mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy];
michael's avatar
michael committed
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
            if(IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag){
                /* FIXME save sub mb types from previous frames (or derive from MVs)
                * so we know exactly what block size to use */
                sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
            }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){
                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
            }else{
                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
            }
1049
        }
1050 1051
    }

michael's avatar
michael committed
1052 1053 1054 1055
    l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
    l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
    l1ref0 = &h->ref_list[1][0].ref_index [0][h->mb2b8_xy[mb_xy]];
    l1ref1 = &h->ref_list[1][0].ref_index [1][h->mb2b8_xy[mb_xy]];
michael's avatar
michael committed
1056 1057 1058 1059 1060 1061 1062
    if(!b8_stride){
        if(s->mb_y&1){
            l1ref0 += h->b8_stride;
            l1ref1 += h->b8_stride;
            l1mv0  +=  2*b4_stride;
            l1mv1  +=  2*b4_stride;
        }
1063
    }
1064

1065 1066 1067 1068 1069
    if(h->direct_spatial_mv_pred){
        int ref[2];
        int mv[2][2];
        int list;

lorenm's avatar
lorenm committed
1070 1071
        /* FIXME interlacing + spatial direct uses wrong colocated block positions */

1072 1073 1074 1075 1076
        /* ref = min(neighbors) */
        for(list=0; list<2; list++){
            int refa = h->ref_cache[list][scan8[0] - 1];
            int refb = h->ref_cache[list][scan8[0] - 8];
            int refc = h->ref_cache[list][scan8[0] - 8 + 4];
1077
            if(refc == PART_NOT_AVAILABLE)
1078
                refc = h->ref_cache[list][scan8[0] - 8 - 1];
1079
            ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);
1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
            if(ref[list] < 0)
                ref[list] = -1;
        }

        if(ref[0] < 0 && ref[1] < 0){
            ref[0] = ref[1] = 0;
            mv[0][0] = mv[0][1] =
            mv[1][0] = mv[1][1] = 0;
        }else{
            for(list=0; list<2; list++){
                if(ref[list] >= 0)
                    pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
                else
                    mv[list][0] = mv[list][1] = 0;
            }
        }

        if(ref[1] < 0){
lorenm's avatar
lorenm committed
1098 1099 1100
            if(!is_b8x8)
                *mb_type &= ~MB_TYPE_L1;
            sub_mb_type &= ~MB_TYPE_L1;
1101
        }else if(ref[0] < 0){
lorenm's avatar
lorenm committed
1102 1103 1104
            if(!is_b8x8)
                *mb_type &= ~MB_TYPE_L0;
            sub_mb_type &= ~MB_TYPE_L0;
1105 1106
        }

1107
        if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
lorenm's avatar
lorenm committed
1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
            for(i8=0; i8<4; i8++){
                int x8 = i8&1;
                int y8 = i8>>1;
                int xy8 = x8+y8*b8_stride;
                int xy4 = 3*x8+y8*b4_stride;
                int a=0, b=0;

                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
                    continue;
                h->sub_mb_type[i8] = sub_mb_type;

                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1121
                if(!IS_INTRA(mb_type_col[y8])
lorenm's avatar
lorenm committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
                   && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)
                       || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){
                    if(ref[0] > 0)
                        a= pack16to32(mv[0][0],mv[0][1]);
                    if(ref[1] > 0)
                        b= pack16to32(mv[1][0],mv[1][1]);
                }else{
                    a= pack16to32(mv[0][0],mv[0][1]);
                    b= pack16to32(mv[1][0],mv[1][1]);
                }
                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4);
                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);
            }
        }else if(IS_16X16(*mb_type)){
michael's avatar
michael committed
1136 1137
            int a=0, b=0;

1138 1139
            fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
            fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
1140
            if(!IS_INTRA(mb_type_col[0])
diego's avatar
diego committed
1141 1142
               && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
                   || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
mru's avatar
mru committed
1143
                       && (h->x264_build>33 || !h->x264_build)))){
1144
                if(ref[0] > 0)
michael's avatar
michael committed
1145
                    a= pack16to32(mv[0][0],mv[0][1]);
1146
                if(ref[1] > 0)
michael's avatar
michael committed
1147
                    b= pack16to32(mv[1][0],mv[1][1]);
1148
            }else{
michael's avatar
michael committed
1149 1150
                a= pack16to32(mv[0][0],mv[0][1]);
                b= pack16to32(mv[1][0],mv[1][1]);
1151
            }
michael's avatar
michael committed
1152 1153
            fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
            fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
1154 1155 1156 1157
        }else{
            for(i8=0; i8<4; i8++){
                const int x8 = i8&1;
                const int y8 = i8>>1;
1158

1159 1160 1161
                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
                    continue;
                h->sub_mb_type[i8] = sub_mb_type;
1162

1163 1164
                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1165 1166
                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1167

1168
                /* col_zero_flag */
1169 1170
                if(!IS_INTRA(mb_type_col[0]) && (   l1ref0[x8 + y8*b8_stride] == 0
                                              || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0
mru's avatar
mru committed
1171
                                                  && (h->x264_build>33 || !h->x264_build)))){
1172
                    const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;
1173
                    if(IS_SUB_8X8(sub_mb_type)){
1174
                        const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
diego's avatar
diego committed
1175
                        if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1176 1177 1178 1179 1180 1181
                            if(ref[0] == 0)
                                fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
                            if(ref[1] == 0)
                                fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
                        }
                    }else
1182
                    for(i4=0; i4<4; i4++){
1183
                        const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
diego's avatar
diego committed
1184
                        if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194
                            if(ref[0] == 0)
                                *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
                            if(ref[1] == 0)
                                *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
                        }
                    }
                }
            }
        }
    }else{ /* direct temporal mv pred */
lorenm's avatar
lorenm committed
1195 1196
        const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
        const int *dist_scale_factor = h->dist_scale_factor;
1197
        int ref_offset= 0;
lorenm's avatar
lorenm committed
1198

michael's avatar
michael committed
1199
        if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){
1200 1201 1202
            map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];
            map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];
            dist_scale_factor   =h->dist_scale_factor_field[s->mb_y&1];
michael's avatar
michael committed
1203
        }
1204
        if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))
1205
            ref_offset += 16;
1206

michael's avatar
michael committed
1207 1208
        if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
            /* FIXME assumes direct_8x8_inference == 1 */
michael's avatar
michael committed
1209
            int y_shift  = 2*!IS_INTERLACED(*mb_type);
lorenm's avatar
lorenm committed
1210

michael's avatar
michael committed
1211 1212 1213 1214 1215
            for(i8=0; i8<4; i8++){
                const int x8 = i8&1;
                const int y8 = i8>>1;
                int ref0, scale;
                const int16_t (*l1mv)[2]= l1mv0;
lorenm's avatar
lorenm committed
1216

michael's avatar
michael committed
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
                    continue;
                h->sub_mb_type[i8] = sub_mb_type;

                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
                if(IS_INTRA(mb_type_col[y8])){
                    fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
                    fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
                    fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
                    continue;
                }

                ref0 = l1ref0[x8 + y8*b8_stride];
                if(ref0 >= 0)
1231
                    ref0 = map_col_to_list0[0][ref0 + ref_offset];
michael's avatar
michael committed
1232
                else{
1233
                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
michael's avatar
michael committed
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
                    l1mv= l1mv1;
                }
                scale = dist_scale_factor[ref0];
                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);

                {
                    const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride];
                    int my_col = (mv_col[1]<<y_shift)/2;
                    int mx = (scale * mv_col[0] + 128) >> 8;
                    int my = (scale * my_col + 128) >> 8;
                    fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
                    fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4);
lorenm's avatar
lorenm committed
1246 1247
                }
            }
michael's avatar
michael committed
1248 1249
            return;
        }
lorenm's avatar
lorenm committed
1250 1251 1252

        /* one-to-one mv scaling */

1253
        if(IS_16X16(*mb_type)){
1254 1255
            int ref, mv0, mv1;

1256
            fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
1257
            if(IS_INTRA(mb_type_col[0])){
1258
                ref=mv0=mv1=0;
1259
            }else{
1260 1261
                const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
                                                : map_col_to_list0[1][l1ref1[0] + ref_offset];
lorenm's avatar
lorenm committed
1262
                const int scale = dist_scale_factor[ref0];
1263
                const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
1264
                int mv_l0[2];
lorenm's avatar
lorenm committed
1265 1266
                mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
                mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1267 1268 1269
                ref= ref0;
                mv0= pack16to32(mv_l0[0],mv_l0[1]);
                mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
1270
            }
1271 1272 1273
            fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
            fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);
            fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);
1274 1275 1276 1277
        }else{
            for(i8=0; i8<4; i8++){
                const int x8 = i8&1;
                const int y8 = i8>>1;
lorenm's avatar
lorenm committed
1278
                int ref0, scale;
mru's avatar
mru committed
1279
                const int16_t (*l1mv)[2]= l1mv0;
1280

1281 1282 1283
                if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
                    continue;
                h->sub_mb_type[i8] = sub_mb_type;
lorenm's avatar
lorenm committed
1284
                fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1285
                if(IS_INTRA(mb_type_col[0])){
1286 1287 1288 1289 1290
                    fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
                    fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
                    fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
                    continue;
                }
1291

1292
                ref0 = l1ref0[x8 + y8*b8_stride] + ref_offset;
1293
                if(ref0 >= 0)
lorenm's avatar
lorenm committed
1294
                    ref0 = map_col_to_list0[0][ref0];
1295
                else{
1296
                    ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset];
1297 1298
                    l1mv= l1mv1;
                }
lorenm's avatar
lorenm committed
1299
                scale = dist_scale_factor[ref0];
1300

1301
                fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1302
                if(IS_SUB_8X8(sub_mb_type)){
1303
                    const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
lorenm's avatar
lorenm committed
1304 1305
                    int mx = (scale * mv_col[0] + 128) >> 8;
                    int my = (scale * mv_col[1] + 128) >> 8;
1306 1307 1308
                    fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
                    fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
                }else
1309
                for(i4=0; i4<4; i4++){
1310
                    const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
1311
                    int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
lorenm's avatar
lorenm committed
1312 1313
                    mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
                    mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
1314 1315 1316 1317 1318 1319 1320 1321
                    *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
                        pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
                }
            }
        }
    }
}

michaelni's avatar
michaelni committed
1322 1323 1324 1325 1326 1327
static inline void write_back_motion(H264Context *h, int mb_type){
    MpegEncContext * const s = &h->s;
    const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
    const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
    int list;

1328 1329 1330
    if(!USES_LIST(mb_type, 0))
        fill_rectangle(&s->current_picture.ref_index[0][b8_xy], 2, 2, h->b8_stride, (uint8_t)LIST_NOT_USED, 1);

1331
    for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
1332
        int y;
1333
        if(!USES_LIST(mb_type, list))
1334
            continue;
1335

michaelni's avatar
michaelni committed
1336 1337 1338 1339
        for(y=0; y<4; y++){
            *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+0 + 8*y];
            *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mv_cache[list][scan8[0]+2 + 8*y];
        }
1340
        if( h->pps.cabac ) {
1341 1342 1343
            if(IS_SKIP(mb_type))
                fill_rectangle(h->mvd_table[list][b_xy], 4, 4, h->b_stride, 0, 4);
            else
1344 1345 1346 1347 1348
            for(y=0; y<4; y++){
                *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
                *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
            }
        }
1349 1350

        {
mru's avatar
mru committed
1351
            int8_t *ref_index = &s->current_picture.ref_index[list][b8_xy];
1352 1353 1354 1355
            ref_index[0+0*h->b8_stride]= h->ref_cache[list][scan8[0]];
            ref_index[1+0*h->b8_stride]= h->ref_cache[list][scan8[4]];
            ref_index[0+1*h->b8_stride]= h->ref_cache[list][scan8[8]];
            ref_index[1+1*h->b8_stride]= h->ref_cache[list][scan8[12]];
michaelni's avatar
michaelni committed
1356 1357
        }
    }
1358

1359
    if(h->slice_type_nos == FF_B_TYPE && h->pps.cabac){
1360
        if(IS_8X8(mb_type)){
1361 1362 1363 1364
            uint8_t *direct_table = &h->direct_table[b8_xy];
            direct_table[1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
            direct_table[0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
            direct_table[1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
1365 1366
        }
    }
michaelni's avatar
michaelni committed
1367 1368 1369 1370 1371 1372
}

/**
 * Decodes a network abstraction layer unit.
 * @param consumed is the number of bytes used as input
 * @param length is the length of the array
1373
 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
1374
 * @returns decoded bytes, might be src+1 if no escapes
michaelni's avatar
michaelni committed
1375
 */
michael's avatar
michael committed
1376
static const uint8_t *decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
michaelni's avatar
michaelni committed
1377 1378
    int i, si, di;
    uint8_t *dst;
1379
    int bufidx;
michaelni's avatar
michaelni committed
1380

1381
//    src[0]&0x80;                //forbidden bit
michaelni's avatar
michaelni committed
1382 1383 1384 1385
    h->nal_ref_idc= src[0]>>5;
    h->nal_unit_type= src[0]&0x1F;

    src++; length--;
1386
#if 0
michaelni's avatar
michaelni committed
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
    for(i=0; i<length; i++)
        printf("%2X ", src[i]);
#endif
    for(i=0; i+1<length; i+=2){
        if(src[i]) continue;
        if(i>0 && src[i-1]==0) i--;
        if(i+2<length && src[i+1]==0 && src[i+2]<=3){
            if(src[i+2]!=3){
                /* startcode, so we must be past the end */
                length=i;
            }
            break;
        }
    }

    if(i>=length-1){ //no escaped 0
        *dst_length= length;
        *consumed= length+1; //+1 for the header
1405
        return src;
michaelni's avatar
michaelni committed
1406 1407
    }

1408 1409 1410
    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
    h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length);
    dst= h->rbsp_buffer[bufidx];
michaelni's avatar
michaelni committed
1411

1412 1413 1414 1415
    if (dst == NULL){
        return NULL;
    }

1416
//printf("decoding esc\n");
michaelni's avatar
michaelni committed
1417
    si=di=0;
1418
    while(si<length){
michaelni's avatar
michaelni committed
1419 1420 1421 1422 1423 1424
        //remove escapes (very rare 1:2^22)
        if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
            if(src[si+2]==3){ //escape
                dst[di++]= 0;
                dst[di++]= 0;
                si+=3;
1425
                continue;
michaelni's avatar
michaelni committed
1426 1427 1428 1429 1430 1431 1432 1433 1434
            }else //next start code
                break;
        }

        dst[di++]= src[si++];
    }

    *dst_length= di;
    *consumed= si + 1;//+1 for the header
diego's avatar
diego committed
1435
//FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
michaelni's avatar
michaelni committed
1436 1437 1438 1439 1440 1441 1442
    return dst;
}

/**
 * identifies the exact end of the bitstream
 * @return the length of the trailing, or 0 if damaged
 */
michael's avatar
michael committed
1443
static int decode_rbsp_trailing(H264Context *h, const uint8_t *src){
michaelni's avatar
michaelni committed
1444 1445 1446
    int v= *src;
    int r;

mbardiaux's avatar
mbardiaux committed
1447
    tprintf(h->s.avctx, "rbsp trailing %X\n", v);
michaelni's avatar
michaelni committed
1448 1449 1450 1451 1452 1453 1454 1455 1456

    for(r=1; r<9; r++){
        if(v&1) return r;
        v>>=1;
    }
    return 0;
}

/**
diego's avatar
diego committed
1457
 * IDCT transforms the 16 dc values and dequantizes them.
michaelni's avatar
michaelni committed
1458 1459
 * @param qp quantization parameter
 */
lorenm's avatar
lorenm committed
1460
static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
michaelni's avatar
michaelni committed
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
#define stride 16
    int i;
    int temp[16]; //FIXME check if this is a good idea
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

//memset(block, 64, 2*256);
//return;
    for(i=0; i<4; i++){
        const int offset= y_offset[i];
        const int z0= block[offset+stride*0] + block[offset+stride*4];
        const int z1= block[offset+stride*0] - block[offset+stride*4];
        const int z2= block[offset+stride*1] - block[offset+stride*5];
        const int z3= block[offset+stride*1] + block[offset+stride*5];

        temp[4*i+0]= z0+z3;
        temp[4*i+1]= z1+z2;
        temp[4*i+2]= z1-z2;
        temp[4*i+3]= z0-z3;
    }

    for(i=0; i<4; i++){
        const int offset= x_offset[i];
        const int z0= temp[4*0+i] + temp[4*2+i];
        const int z1= temp[4*0+i] - temp[4*2+i];
        const int z2= temp[4*1+i] - temp[4*3+i];
        const int z3= temp[4*1+i] + temp[4*3+i];

diego's avatar
diego committed
1489
        block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual
lorenm's avatar
lorenm committed
1490 1491 1492
        block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
        block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
        block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
michaelni's avatar
michaelni committed
1493 1494 1495
    }
}

1496
#if 0
michaelni's avatar
michaelni committed
1497
/**
diego's avatar
diego committed
1498
 * DCT transforms the 16 dc values.
michaelni's avatar
michaelni committed
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
 * @param qp quantization parameter ??? FIXME
 */
static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
//    const int qmul= dequant_coeff[qp][0];
    int i;
    int temp[16]; //FIXME check if this is a good idea
    static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
    static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};

    for(i=0; i<4; i++){
        const int offset= y_offset[i];
        const int z0= block[offset+stride*0] + block[offset+stride*4];
        const int z1= block[offset+stride*0] - block[offset+stride*4];
        const int z2= block[offset+stride*1] - block[offset+stride*5];
        const int z3= block[offset+stride*1] + block[offset+stride*5];

        temp[4*i+0]= z0+z3;
        temp[4*i+1]= z1+z2;
        temp[4*i+2]= z1-z2;
        temp[4*i+3]= z0-z3;
    }

    for(i=0; i<4; i++){
        const int offset= x_offset[i];
        const int z0= temp[4*0+i] + temp[4*2+i];
        const int z1= temp[4*0+i] - temp[4*2+i];
        const int z2= temp[4*1+i] - temp[4*3+i];
        const int z3= temp[4*1+i] + temp[4*3+i];

        block[stride*0 +offset]= (z0 + z3)>>1;
        block[stride*2 +offset]= (z1 + z2)>>1;
        block[stride*8 +offset]= (z1 - z2)>>1;
        block[stride*10+offset]= (z0 - z3)>>1;
    }
}
1534 1535
#endif

michaelni's avatar
michaelni committed
1536 1537 1538
#undef xStride
#undef stride

lorenm's avatar
lorenm committed
1539
static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
michaelni's avatar
michaelni committed
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
    const int stride= 16*2;
    const int xStride= 16;
    int a,b,c,d,e;

    a= block[stride*0 + xStride*0];
    b= block[stride*0 + xStride*1];
    c= block[stride*1 + xStride*0];
    d= block[stride*1 + xStride*1];

    e= a-b;
    a= a+b;
    b= c-d;
    c= c+d;

lorenm's avatar
lorenm committed
1554 1555 1556 1557
    block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
    block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
    block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
    block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
michaelni's avatar
michaelni committed
1558 1559
}

1560
#if 0
michaelni's avatar
michaelni committed
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
static void chroma_dc_dct_c(DCTELEM *block){
    const int stride= 16*2;
    const int xStride= 16;
    int a,b,c,d,e;

    a= block[stride*0 + xStride*0];
    b= block[stride*0 + xStride*1];
    c= block[stride*1 + xStride*0];
    d= block[stride*1 + xStride*1];

    e= a-b;
    a= a+b;
    b= c-d;
    c= c+d;

    block[stride*0 + xStride*0]= (a+c);
    block[stride*0 + xStride*1]= (e+b);
    block[stride*1 + xStride*0]= (a-c);
    block[stride*1 + xStride*1]= (e-b);
}
1581
#endif
michaelni's avatar
michaelni committed
1582 1583 1584 1585

/**
 * gets the chroma qp.
 */
1586
static inline int get_chroma_qp(H264Context *h, int t, int qscale){
1587
    return h->pps.chroma_qp_table[t][qscale];
michaelni's avatar
michaelni committed
1588 1589 1590 1591 1592 1593 1594 1595
}

static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                           int src_x_offset, int src_y_offset,
                           qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
    MpegEncContext * const s = &h->s;
    const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
lorenm's avatar
lorenm committed
1596
    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
michaelni's avatar
michaelni committed
1597
    const int luma_xy= (mx&3) + ((my&3)<<2);
lorenm's avatar
lorenm committed
1598 1599 1600 1601
    uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize;
    uint8_t * src_cb, * src_cr;
    int extra_width= h->emu_edge_width;
    int extra_height= h->emu_edge_height;
michaelni's avatar
michaelni committed
1602 1603 1604
    int emu=0;
    const int full_mx= mx>>2;
    const int full_my= my>>2;
1605
    const int pic_width  = 16*s->mb_width;
1606
    const int pic_height = 16*s->mb_height >> MB_FIELD;
1607

diego's avatar
diego committed
1608
    if(!pic->data[0]) //FIXME this is unacceptable, some sensible error concealment must be done for missing reference frames
1609
        return;
1610

michaelni's avatar
michaelni committed
1611 1612
    if(mx&7) extra_width -= 3;
    if(my&7) extra_height -= 3;
1613 1614 1615 1616

    if(   full_mx < 0-extra_width
       || full_my < 0-extra_height
       || full_mx + 16/*FIXME*/ > pic_width + extra_width
1617
       || full_my + 16/*FIXME*/ > pic_height + extra_height){
lorenm's avatar
lorenm committed
1618 1619
        ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
            src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize;
michaelni's avatar
michaelni committed
1620 1621
        emu=1;
    }
1622

lorenm's avatar
lorenm committed
1623
    qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps?
michaelni's avatar
michaelni committed
1624
    if(!square){
lorenm's avatar
lorenm committed
1625
        qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize);
michaelni's avatar
michaelni committed
1626
    }
1627

michael's avatar
michael committed
1628
    if(ENABLE_GRAY && s->flags&CODEC_FLAG_GRAY) return;
1629

1630
    if(MB_FIELD){
lorenm's avatar
lorenm committed
1631
        // chroma offset when predicting from a field of opposite parity
1632
        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
lorenm's avatar
lorenm committed
1633 1634 1635 1636 1637
        emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
    }
    src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize;
    src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize;

michaelni's avatar
michaelni committed
1638
    if(emu){
lorenm's avatar
lorenm committed
1639
        ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
michaelni's avatar
michaelni committed
1640 1641
            src_cb= s->edge_emu_buffer;
    }
lorenm's avatar
lorenm committed
1642
    chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
michaelni's avatar
michaelni committed
1643 1644

    if(emu){
lorenm's avatar
lorenm committed
1645
        ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
michaelni's avatar
michaelni committed
1646 1647
            src_cr= s->edge_emu_buffer;
    }
lorenm's avatar
lorenm committed
1648
    chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
michaelni's avatar
michaelni committed
1649 1650
}

lorenm's avatar
lorenm committed
1651
static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
michaelni's avatar
michaelni committed
1652 1653 1654 1655 1656 1657 1658 1659
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                           int x_offset, int y_offset,
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
                           int list0, int list1){
    MpegEncContext * const s = &h->s;
    qpel_mc_func *qpix_op=  qpix_put;
    h264_chroma_mc_func chroma_op= chroma_put;
1660

lorenm's avatar
lorenm committed
1661 1662 1663
    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;
    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;
    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;
michaelni's avatar
michaelni committed
1664
    x_offset += 8*s->mb_x;
1665
    y_offset += 8*(s->mb_y >> MB_FIELD);
1666

michaelni's avatar
michaelni committed
1667
    if(list0){
1668
        Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
michaelni's avatar
michaelni committed
1669 1670 1671 1672 1673 1674 1675 1676 1677
        mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
                           qpix_op, chroma_op);

        qpix_op=  qpix_avg;
        chroma_op= chroma_avg;
    }

    if(list1){
1678
        Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
michaelni's avatar
michaelni committed
1679 1680 1681 1682 1683 1684
        mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
                           dest_y, dest_cb, dest_cr, x_offset, y_offset,
                           qpix_op, chroma_op);
    }
}

lorenm's avatar
lorenm committed
1685 1686 1687 1688 1689 1690 1691 1692 1693
static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                           int x_offset, int y_offset,
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
                           h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
                           h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
                           int list0, int list1){
    MpegEncContext * const s = &h->s;

lorenm's avatar
lorenm committed
1694 1695 1696
    dest_y  += 2*x_offset + 2*y_offset*h->  mb_linesize;
    dest_cb +=   x_offset +   y_offset*h->mb_uvlinesize;
    dest_cr +=   x_offset +   y_offset*h->mb_uvlinesize;
lorenm's avatar
lorenm committed
1697
    x_offset += 8*s->mb_x;
1698
    y_offset += 8*(s->mb_y >> MB_FIELD);
1699

lorenm's avatar
lorenm committed
1700 1701 1702 1703
    if(list0 && list1){
        /* don't optimize for luma-only case, since B-frames usually
         * use implicit weights => chroma too. */
        uint8_t *tmp_cb = s->obmc_scratchpad;
lorenm's avatar
lorenm committed
1704 1705
        uint8_t *tmp_cr = s->obmc_scratchpad + 8;
        uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;
lorenm's avatar
lorenm committed
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
        int refn0 = h->ref_cache[0][ scan8[n] ];
        int refn1 = h->ref_cache[1][ scan8[n] ];

        mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
                    dest_y, dest_cb, dest_cr,
                    x_offset, y_offset, qpix_put, chroma_put);
        mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
                    tmp_y, tmp_cb, tmp_cr,
                    x_offset, y_offset, qpix_put, chroma_put);

        if(h->use_weight == 2){
            int weight0 = h->implicit_weight[refn0][refn1];
            int weight1 = 64 - weight0;
lorenm's avatar
lorenm committed
1719 1720 1721
            luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
lorenm's avatar
lorenm committed
1722
        }else{
lorenm's avatar
lorenm committed
1723
            luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
1724
                            h->luma_weight[0][refn0], h->luma_weight[1][refn1],
lorenm's avatar
lorenm committed
1725
                            h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
lorenm's avatar
lorenm committed
1726
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1727
                            h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
lorenm's avatar
lorenm committed
1728
                            h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
lorenm's avatar
lorenm committed
1729
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1730
                            h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
lorenm's avatar
lorenm committed
1731
                            h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
lorenm's avatar
lorenm committed
1732 1733 1734 1735 1736 1737 1738 1739 1740
        }
    }else{
        int list = list1 ? 1 : 0;
        int refn = h->ref_cache[list][ scan8[n] ];
        Picture *ref= &h->ref_list[list][refn];
        mc_dir_part(h, ref, n, square, chroma_height, delta, list,
                    dest_y, dest_cb, dest_cr, x_offset, y_offset,
                    qpix_put, chroma_put);

lorenm's avatar
lorenm committed
1741
        luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
lorenm's avatar
lorenm committed
1742 1743
                       h->luma_weight[list][refn], h->luma_offset[list][refn]);
        if(h->use_weight_chroma){
lorenm's avatar
lorenm committed
1744
            chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
lorenm's avatar
lorenm committed
1745
                             h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
lorenm's avatar
lorenm committed
1746
            chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
lorenm's avatar
lorenm committed
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
                             h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
        }
    }
}

static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
                           uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                           int x_offset, int y_offset,
                           qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
                           qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
1757
                           h264_weight_func *weight_op, h264_biweight_func *weight_avg,
lorenm's avatar
lorenm committed
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
                           int list0, int list1){
    if((h->use_weight==2 && list0 && list1
        && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
       || h->use_weight==1)
        mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
                         x_offset, y_offset, qpix_put, chroma_put,
                         weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
    else
        mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
                    x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
}

1770 1771 1772 1773 1774 1775 1776 1777 1778
static inline void prefetch_motion(H264Context *h, int list){
    /* fetch pixels for estimated mv 4 macroblocks ahead
     * optimized for 64byte cache lines */
    MpegEncContext * const s = &h->s;
    const int refn = h->ref_cache[list][scan8[0]];
    if(refn >= 0){
        const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8;
        const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y;
        uint8_t **src= h->ref_list[list][refn].data;
lorenm's avatar
lorenm committed
1779
        int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
1780 1781 1782 1783 1784 1785
        s->dsp.prefetch(src[0]+off, s->linesize, 4);
        off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64;
        s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
    }
}

michaelni's avatar
michaelni committed
1786 1787
static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
                      qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
lorenm's avatar
lorenm committed
1788 1789
                      qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
                      h264_weight_func *weight_op, h264_biweight_func *weight_avg){
michaelni's avatar
michaelni committed
1790
    MpegEncContext * const s = &h->s;
1791
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
1792
    const int mb_type= s->current_picture.mb_type[mb_xy];
1793

michaelni's avatar
michaelni committed
1794
    assert(IS_INTER(mb_type));
1795

1796 1797
    prefetch_motion(h, 0);

michaelni's avatar
michaelni committed
1798 1799 1800
    if(IS_16X16(mb_type)){
        mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
                qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
lorenm's avatar
lorenm committed
1801
                &weight_op[0], &weight_avg[0],
michaelni's avatar
michaelni committed
1802 1803 1804 1805
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
    }else if(IS_16X8(mb_type)){
        mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
lorenm's avatar
lorenm committed
1806
                &weight_op[1], &weight_avg[1],
michaelni's avatar
michaelni committed
1807 1808 1809
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
        mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
                qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
lorenm's avatar
lorenm committed
1810
                &weight_op[1], &weight_avg[1],
michaelni's avatar
michaelni committed
1811 1812
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
    }else if(IS_8X16(mb_type)){
lorenm's avatar
lorenm committed
1813
        mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
michaelni's avatar
michaelni committed
1814
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
lorenm's avatar
lorenm committed
1815
                &weight_op[2], &weight_avg[2],
michaelni's avatar
michaelni committed
1816
                IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
lorenm's avatar
lorenm committed
1817
        mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
michaelni's avatar
michaelni committed
1818
                qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
lorenm's avatar
lorenm committed
1819
                &weight_op[2], &weight_avg[2],
michaelni's avatar
michaelni committed
1820 1821 1822
                IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
    }else{
        int i;
1823

michaelni's avatar
michaelni committed
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
        assert(IS_8X8(mb_type));

        for(i=0; i<4; i++){
            const int sub_mb_type= h->sub_mb_type[i];
            const int n= 4*i;
            int x_offset= (i&1)<<2;
            int y_offset= (i&2)<<1;

            if(IS_SUB_8X8(sub_mb_type)){
                mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
                    qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
lorenm's avatar
lorenm committed
1835
                    &weight_op[3], &weight_avg[3],
michaelni's avatar
michaelni committed
1836 1837 1838 1839
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
            }else if(IS_SUB_8X4(sub_mb_type)){
                mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
lorenm's avatar
lorenm committed
1840
                    &weight_op[4], &weight_avg[4],
michaelni's avatar
michaelni committed
1841 1842 1843
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
                mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
                    qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
lorenm's avatar
lorenm committed
1844
                    &weight_op[4], &weight_avg[4],
michaelni's avatar
michaelni committed
1845 1846
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
            }else if(IS_SUB_4X8(sub_mb_type)){
lorenm's avatar
lorenm committed
1847
                mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
michaelni's avatar
michaelni committed
1848
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
lorenm's avatar
lorenm committed
1849
                    &weight_op[5], &weight_avg[5],
michaelni's avatar
michaelni committed
1850
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
lorenm's avatar
lorenm committed
1851
                mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
michaelni's avatar
michaelni committed
1852
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
lorenm's avatar
lorenm committed
1853
                    &weight_op[5], &weight_avg[5],
michaelni's avatar
michaelni committed
1854 1855 1856 1857 1858 1859 1860 1861 1862
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
            }else{
                int j;
                assert(IS_SUB_4X4(sub_mb_type));
                for(j=0; j<4; j++){
                    int sub_x_offset= x_offset + 2*(j&1);
                    int sub_y_offset= y_offset +   (j&2);
                    mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
                        qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
lorenm's avatar
lorenm committed
1863
                        &weight_op[6], &weight_avg[6],
michaelni's avatar
michaelni committed
1864 1865 1866 1867 1868
                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
                }
            }
        }
    }
1869 1870

    prefetch_motion(h, 1);
michaelni's avatar
michaelni committed
1871 1872
}

1873
static av_cold void decode_init_vlc(void){
michaelni's avatar
michaelni committed
1874 1875 1876 1877
    static int done = 0;

    if (!done) {
        int i;
cehoyos's avatar
cehoyos committed
1878
        int offset;
michaelni's avatar
michaelni committed
1879 1880
        done = 1;

cehoyos's avatar
cehoyos committed
1881 1882
        chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
        chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
1883
        init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
michaelni's avatar
michaelni committed
1884
                 &chroma_dc_coeff_token_len [0], 1, 1,
cehoyos's avatar
cehoyos committed
1885 1886
                 &chroma_dc_coeff_token_bits[0], 1, 1,
                 INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1887

cehoyos's avatar
cehoyos committed
1888
        offset = 0;
michaelni's avatar
michaelni committed
1889
        for(i=0; i<4; i++){
cehoyos's avatar
cehoyos committed
1890 1891
            coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
            coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
1892
            init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
michaelni's avatar
michaelni committed
1893
                     &coeff_token_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1894 1895 1896
                     &coeff_token_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
            offset += coeff_token_vlc_tables_size[i];
michaelni's avatar
michaelni committed
1897
        }
cehoyos's avatar
cehoyos committed
1898 1899 1900 1901 1902
        /*
         * This is a one time safety check to make sure that
         * the packed static coeff_token_vlc table sizes
         * were initialized correctly.
         */
1903
        assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
michaelni's avatar
michaelni committed
1904 1905

        for(i=0; i<3; i++){
cehoyos's avatar
cehoyos committed
1906 1907 1908 1909
            chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
            chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
            init_vlc(&chroma_dc_total_zeros_vlc[i],
                     CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
michaelni's avatar
michaelni committed
1910
                     &chroma_dc_total_zeros_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1911 1912
                     &chroma_dc_total_zeros_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1913 1914
        }
        for(i=0; i<15; i++){
cehoyos's avatar
cehoyos committed
1915 1916 1917 1918
            total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
            total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
            init_vlc(&total_zeros_vlc[i],
                     TOTAL_ZEROS_VLC_BITS, 16,
michaelni's avatar
michaelni committed
1919
                     &total_zeros_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1920 1921
                     &total_zeros_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1922 1923 1924
        }

        for(i=0; i<6; i++){
cehoyos's avatar
cehoyos committed
1925 1926 1927 1928
            run_vlc[i].table = run_vlc_tables[i];
            run_vlc[i].table_allocated = run_vlc_tables_size;
            init_vlc(&run_vlc[i],
                     RUN_VLC_BITS, 7,
michaelni's avatar
michaelni committed
1929
                     &run_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1930 1931
                     &run_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1932
        }
cehoyos's avatar
cehoyos committed
1933 1934
        run7_vlc.table = run7_vlc_table,
        run7_vlc.table_allocated = run7_vlc_table_size;
1935
        init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
michaelni's avatar
michaelni committed
1936
                 &run_len [6][0], 1, 1,
cehoyos's avatar
cehoyos committed
1937 1938
                 &run_bits[6][0], 1, 1,
                 INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1939 1940 1941 1942
    }
}

static void free_tables(H264Context *h){
benoit's avatar
 
benoit committed
1943
    int i;
1944
    H264Context *hx;
michaelni's avatar
michaelni committed
1945
    av_freep(&h->intra4x4_pred_mode);
1946 1947
    av_freep(&h->chroma_pred_mode_table);
    av_freep(&h->cbp_table);
1948 1949
    av_freep(&h->mvd_table[0]);
    av_freep(&h->mvd_table[1]);
1950
    av_freep(&h->direct_table);
michaelni's avatar
michaelni committed
1951 1952 1953
    av_freep(&h->non_zero_count);
    av_freep(&h->slice_table_base);
    h->slice_table= NULL;
1954

michaelni's avatar
michaelni committed
1955 1956
    av_freep(&h->mb2b_xy);
    av_freep(&h->mb2b8_xy);
lorenm's avatar
lorenm committed
1957

1958 1959 1960 1961 1962 1963 1964
    for(i = 0; i < h->s.avctx->thread_count; i++) {
        hx = h->thread_context[i];
        if(!hx) continue;
        av_freep(&hx->top_borders[1]);
        av_freep(&hx->top_borders[0]);
        av_freep(&hx->s.obmc_scratchpad);
    }
michaelni's avatar
michaelni committed
1965 1966
}

lorenm's avatar
lorenm committed
1967 1968
static void init_dequant8_coeff_table(H264Context *h){
    int i,q,x;
lorenm's avatar
lorenm committed
1969
    const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
lorenm's avatar
lorenm committed
1970 1971 1972 1973 1974 1975 1976 1977 1978 1979
    h->dequant8_coeff[0] = h->dequant8_buffer[0];
    h->dequant8_coeff[1] = h->dequant8_buffer[1];

    for(i=0; i<2; i++ ){
        if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
            h->dequant8_coeff[1] = h->dequant8_buffer[0];
            break;
        }

        for(q=0; q<52; q++){
1980 1981
            int shift = div6[q];
            int idx = rem6[q];
lorenm's avatar
lorenm committed
1982
            for(x=0; x<64; x++)
lorenm's avatar
lorenm committed
1983 1984 1985
                h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] =
                    ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
                    h->pps.scaling_matrix8[i][x]) << shift;
lorenm's avatar
lorenm committed
1986 1987 1988 1989 1990 1991
        }
    }
}

static void init_dequant4_coeff_table(H264Context *h){
    int i,j,q,x;
1992
    const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
lorenm's avatar
lorenm committed
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
    for(i=0; i<6; i++ ){
        h->dequant4_coeff[i] = h->dequant4_buffer[i];
        for(j=0; j<i; j++){
            if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
                h->dequant4_coeff[i] = h->dequant4_buffer[j];
                break;
            }
        }
        if(j<i)
            continue;

        for(q=0; q<52; q++){
2005 2006
            int shift = div6[q] + 2;
            int idx = rem6[q];
lorenm's avatar
lorenm committed
2007
            for(x=0; x<16; x++)
2008 2009
                h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
                    ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
lorenm's avatar
lorenm committed
2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
                    h->pps.scaling_matrix4[i][x]) << shift;
        }
    }
}

static void init_dequant_tables(H264Context *h){
    int i,x;
    init_dequant4_coeff_table(h);
    if(h->pps.transform_8x8_mode)
        init_dequant8_coeff_table(h);
    if(h->sps.transform_bypass){
        for(i=0; i<6; i++)
            for(x=0; x<16; x++)
                h->dequant4_coeff[i][0][x] = 1<<6;
        if(h->pps.transform_8x8_mode)
            for(i=0; i<2; i++)
                for(x=0; x<64; x++)
                    h->dequant8_coeff[i][0][x] = 1<<6;
    }
}


michaelni's avatar
michaelni committed
2032 2033
/**
 * allocates tables.
2034
 * needs width/height
michaelni's avatar
michaelni committed
2035 2036 2037
 */
static int alloc_tables(H264Context *h){
    MpegEncContext * const s = &h->s;
2038
    const int big_mb_num= s->mb_stride * (s->mb_height+1);
lorenm's avatar
lorenm committed
2039
    int x,y;
michaelni's avatar
michaelni committed
2040 2041

    CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8  * sizeof(uint8_t))
2042

2043
    CHECKED_ALLOCZ(h->non_zero_count    , big_mb_num * 16 * sizeof(uint8_t))
2044
    CHECKED_ALLOCZ(h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base))
michael's avatar
michael committed
2045
    CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
michaelni's avatar
michaelni committed
2046

2047 2048 2049 2050
    CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
    CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
    CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
    CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
2051

2052
    memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));
lorenm's avatar
lorenm committed
2053
    h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
michaelni's avatar
michaelni committed
2054

2055 2056
    CHECKED_ALLOCZ(h->mb2b_xy  , big_mb_num * sizeof(uint32_t));
    CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
michaelni's avatar
michaelni committed
2057 2058
    for(y=0; y<s->mb_height; y++){
        for(x=0; x<s->mb_width; x++){
2059
            const int mb_xy= x + y*s->mb_stride;
michaelni's avatar
michaelni committed
2060 2061
            const int b_xy = 4*x + 4*y*h->b_stride;
            const int b8_xy= 2*x + 2*y*h->b8_stride;
2062

michaelni's avatar
michaelni committed
2063 2064 2065 2066
            h->mb2b_xy [mb_xy]= b_xy;
            h->mb2b8_xy[mb_xy]= b8_xy;
        }
    }
lorenm's avatar
lorenm committed
2067

2068 2069
    s->obmc_scratchpad = NULL;

2070 2071 2072
    if(!h->dequant4_coeff[0])
        init_dequant_tables(h);

michaelni's avatar
michaelni committed
2073 2074 2075 2076 2077 2078
    return 0;
fail:
    free_tables(h);
    return -1;
}

2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
/**
 * Mimic alloc_tables(), but for every context thread.
 */
static void clone_tables(H264Context *dst, H264Context *src){
    dst->intra4x4_pred_mode       = src->intra4x4_pred_mode;
    dst->non_zero_count           = src->non_zero_count;
    dst->slice_table              = src->slice_table;
    dst->cbp_table                = src->cbp_table;
    dst->mb2b_xy                  = src->mb2b_xy;
    dst->mb2b8_xy                 = src->mb2b8_xy;
    dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;
    dst->mvd_table[0]             = src->mvd_table[0];
    dst->mvd_table[1]             = src->mvd_table[1];
    dst->direct_table             = src->direct_table;

    dst->s.obmc_scratchpad = NULL;
    ff_h264_pred_init(&dst->hpc, src->s.codec_id);
}

/**
 * Init context
 * Allocate buffers which are not shared amongst multiple threads.
 */
static int context_init(H264Context *h){
    CHECKED_ALLOCZ(h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t))
    CHECKED_ALLOCZ(h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t))

    return 0;
fail:
    return -1; // free_tables will clean up for us
}

2111
static av_cold void common_init(H264Context *h){
michaelni's avatar
michaelni committed
2112 2113 2114 2115 2116
    MpegEncContext * const s = &h->s;

    s->width = s->avctx->width;
    s->height = s->avctx->height;
    s->codec_id= s->avctx->codec->id;
2117

2118
    ff_h264_pred_init(&h->hpc, s->codec_id);
michaelni's avatar
michaelni committed
2119

lorenm's avatar
lorenm committed
2120
    h->dequant_coeff_pps= -1;
michael's avatar
michael committed
2121
    s->unrestricted_mv=1;
michaelni's avatar
michaelni committed
2122
    s->decode=1; //FIXME
2123 2124 2125

    memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
    memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
michaelni's avatar
michaelni committed
2126 2127
}

2128
static av_cold int decode_init(AVCodecContext *avctx){
michaelni's avatar
michaelni committed
2129 2130 2131
    H264Context *h= avctx->priv_data;
    MpegEncContext * const s = &h->s;

michael's avatar
michael committed
2132
    MPV_decode_defaults(s);
2133

michaelni's avatar
michaelni committed
2134 2135 2136 2137 2138 2139 2140 2141
    s->avctx = avctx;
    common_init(h);

    s->out_format = FMT_H264;
    s->workaround_bugs= avctx->workaround_bugs;

    // set defaults
//    s->decode_mb= ff_h263_decode_mb;
2142
    s->quarter_sample = 1;
michaelni's avatar
michaelni committed
2143
    s->low_delay= 1;
2144 2145 2146 2147

    if(avctx->codec_id == CODEC_ID_SVQ3)
        avctx->pix_fmt= PIX_FMT_YUVJ420P;
    else
michael's avatar
michael committed
2148
        avctx->pix_fmt= PIX_FMT_YUV420P;
michaelni's avatar
michaelni committed
2149

2150
    decode_init_vlc();
2151

2152 2153
    if(avctx->extradata_size > 0 && avctx->extradata &&
       *(char *)avctx->extradata == 1){
2154 2155
        h->is_avc = 1;
        h->got_avcC = 0;
2156 2157
    } else {
        h->is_avc = 0;
2158 2159
    }

2160
    h->thread_context[0] = h;
2161
    h->outputed_poc = INT_MIN;
2162
    h->prev_poc_msb= 1<<16;
michaelni's avatar
michaelni committed
2163 2164 2165
    return 0;
}

2166
static int frame_start(H264Context *h){
michaelni's avatar
michaelni committed
2167 2168 2169
    MpegEncContext * const s = &h->s;
    int i;

2170 2171
    if(MPV_frame_start(s, s->avctx) < 0)
        return -1;
michaelni's avatar
michaelni committed
2172
    ff_er_frame_start(s);
2173 2174 2175
    /*
     * MPV_frame_start uses pict_type to derive key_frame.
     * This is incorrect for H.264; IDR markings must be used.
diego's avatar
diego committed
2176
     * Zero here; IDR markings per slice in frame or fields are ORed in later.
2177 2178 2179
     * See decode_nal_units().
     */
    s->current_picture_ptr->key_frame= 0;
michaelni's avatar
michaelni committed
2180 2181 2182 2183 2184

    assert(s->linesize && s->uvlinesize);

    for(i=0; i<16; i++){
        h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
2185
        h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
michaelni's avatar
michaelni committed
2186 2187 2188 2189
    }
    for(i=0; i<4; i++){
        h->block_offset[16+i]=
        h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
2190 2191
        h->block_offset[24+16+i]=
        h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
michaelni's avatar
michaelni committed
2192 2193
    }

2194 2195
    /* can't be in alloc_tables because linesize isn't known there.
     * FIXME: redo bipred weight to not require extra buffer? */
2196 2197 2198
    for(i = 0; i < s->avctx->thread_count; i++)
        if(!h->thread_context[i]->s.obmc_scratchpad)
            h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
lorenm's avatar
lorenm committed
2199 2200

    /* some macroblocks will be accessed before they're available */
2201
    if(FRAME_MBAFF || s->avctx->thread_count > 1)
2202
        memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
2203

michaelni's avatar
michaelni committed
2204
//    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
2205

diego's avatar
diego committed
2206
    // We mark the current picture as non-reference after allocating it, so
2207 2208 2209 2210 2211 2212 2213
    // that if we break out due to an error it can be released automatically
    // in the next MPV_frame_start().
    // SVQ3 as well as most other codecs have only last/next/current and thus
    // get released even with set reference, besides SVQ3 and others do not
    // mark frames as reference later "naturally".
    if(s->codec_id != CODEC_ID_SVQ3)
        s->current_picture_ptr->reference= 0;
2214 2215 2216

    s->current_picture_ptr->field_poc[0]=
    s->current_picture_ptr->field_poc[1]= INT_MAX;
2217
    assert(s->current_picture_ptr->long_ref==0);
2218

2219
    return 0;
michaelni's avatar
michaelni committed
2220 2221
}

2222
static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){
2223 2224
    MpegEncContext * const s = &h->s;
    int i;
2225 2226 2227 2228 2229
    int step    = 1;
    int offset  = 1;
    int uvoffset= 1;
    int top_idx = 1;
    int skiplast= 0;
2230

2231 2232 2233 2234
    src_y  -=   linesize;
    src_cb -= uvlinesize;
    src_cr -= uvlinesize;

2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262
    if(!simple && FRAME_MBAFF){
        if(s->mb_y&1){
            offset  = MB_MBAFF ? 1 : 17;
            uvoffset= MB_MBAFF ? 1 : 9;
            if(!MB_MBAFF){
                *(uint64_t*)(h->top_borders[0][s->mb_x]+ 0)= *(uint64_t*)(src_y +  15*linesize);
                *(uint64_t*)(h->top_borders[0][s->mb_x]+ 8)= *(uint64_t*)(src_y +8+15*linesize);
                if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
                    *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+7*uvlinesize);
                    *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+7*uvlinesize);
                }
            }
        }else{
            if(!MB_MBAFF){
                h->left_border[0]= h->top_borders[0][s->mb_x][15];
                if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
                    h->left_border[34   ]= h->top_borders[0][s->mb_x][16+7  ];
                    h->left_border[34+18]= h->top_borders[0][s->mb_x][16+8+7];
                }
                skiplast= 1;
            }
            offset  =
            uvoffset=
            top_idx = MB_MBAFF ? 0 : 1;
        }
        step= MB_MBAFF ? 2 : 1;
    }

2263
    // There are two lines saved, the line above the the top macroblock of a pair,
2264
    // and the line above the bottom macroblock
2265 2266 2267
    h->left_border[offset]= h->top_borders[top_idx][s->mb_x][15];
    for(i=1; i<17 - skiplast; i++){
        h->left_border[offset+i*step]= src_y[15+i*  linesize];
2268
    }
2269

2270 2271
    *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);
    *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
2272

michael's avatar
michael committed
2273
    if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2274 2275 2276 2277 2278
        h->left_border[uvoffset+34   ]= h->top_borders[top_idx][s->mb_x][16+7];
        h->left_border[uvoffset+34+18]= h->top_borders[top_idx][s->mb_x][24+7];
        for(i=1; i<9 - skiplast; i++){
            h->left_border[uvoffset+34   +i*step]= src_cb[7+i*uvlinesize];
            h->left_border[uvoffset+34+18+i*step]= src_cr[7+i*uvlinesize];
2279
        }
2280 2281
        *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
        *(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
2282 2283 2284
    }
}

2285
static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple){
2286 2287 2288
    MpegEncContext * const s = &h->s;
    int temp8, i;
    uint64_t temp64;
2289 2290 2291
    int deblock_left;
    int deblock_top;
    int mb_xy;
2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
    int step    = 1;
    int offset  = 1;
    int uvoffset= 1;
    int top_idx = 1;

    if(!simple && FRAME_MBAFF){
        if(s->mb_y&1){
            offset  = MB_MBAFF ? 1 : 17;
            uvoffset= MB_MBAFF ? 1 : 9;
        }else{
            offset  =
            uvoffset=
            top_idx = MB_MBAFF ? 0 : 1;
        }
        step= MB_MBAFF ? 2 : 1;
    }
2308 2309

    if(h->deblocking_filter == 2) {
2310
        mb_xy = h->mb_xy;
2311 2312 2313 2314
        deblock_left = h->slice_table[mb_xy] == h->slice_table[mb_xy - 1];
        deblock_top  = h->slice_table[mb_xy] == h->slice_table[h->top_mb_xy];
    } else {
        deblock_left = (s->mb_x > 0);
2315
        deblock_top =  (s->mb_y > !!MB_FIELD);
2316
    }
2317 2318 2319 2320 2321 2322 2323 2324 2325 2326

    src_y  -=   linesize + 1;
    src_cb -= uvlinesize + 1;
    src_cr -= uvlinesize + 1;

#define XCHG(a,b,t,xchg)\
t= a;\
if(xchg)\
    a= b;\
b= t;
2327 2328

    if(deblock_left){
2329 2330
        for(i = !deblock_top; i<16; i++){
            XCHG(h->left_border[offset+i*step], src_y [i*  linesize], temp8, xchg);
2331
        }
2332
        XCHG(h->left_border[offset+i*step], src_y [i*  linesize], temp8, 1);
2333 2334 2335
    }

    if(deblock_top){
2336 2337
        XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
        XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
reimar's avatar
reimar committed
2338
        if(s->mb_x+1 < s->mb_width){
2339
            XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
lorenm's avatar
lorenm committed
2340
        }
2341 2342
    }

michael's avatar
michael committed
2343
    if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2344
        if(deblock_left){
2345 2346 2347
            for(i = !deblock_top; i<8; i++){
                XCHG(h->left_border[uvoffset+34   +i*step], src_cb[i*uvlinesize], temp8, xchg);
                XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, xchg);
2348
            }
2349 2350
            XCHG(h->left_border[uvoffset+34   +i*step], src_cb[i*uvlinesize], temp8, 1);
            XCHG(h->left_border[uvoffset+34+18+i*step], src_cr[i*uvlinesize], temp8, 1);
2351 2352
        }
        if(deblock_top){
2353 2354
            XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
            XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
2355 2356 2357 2358
        }
    }
}

2359
static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
michaelni's avatar
michaelni committed
2360 2361 2362
    MpegEncContext * const s = &h->s;
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
2363
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
2364 2365 2366 2367
    const int mb_type= s->current_picture.mb_type[mb_xy];
    uint8_t  *dest_y, *dest_cb, *dest_cr;
    int linesize, uvlinesize /*dct_offset*/;
    int i;
2368
    int *block_offset = &h->block_offset[0];
michael's avatar
michael committed
2369 2370
    const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
    const int is_h264 = simple || s->codec_id == CODEC_ID_H264;
lorenm's avatar
lorenm committed
2371
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
2372
    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
michaelni's avatar
michaelni committed
2373

2374 2375 2376
    dest_y  = s->current_picture.data[0] + (mb_x + mb_y * s->linesize  ) * 16;
    dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8;
    dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8;
michaelni's avatar
michaelni committed
2377

lorenm's avatar
lorenm committed
2378 2379 2380
    s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4);
    s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2);

2381
    if (!simple && MB_FIELD) {
lorenm's avatar
lorenm committed
2382 2383
        linesize   = h->mb_linesize   = s->linesize * 2;
        uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2384
        block_offset = &h->block_offset[24];
diego's avatar
diego committed
2385
        if(mb_y&1){ //FIXME move out of this function?
michaelni's avatar
michaelni committed
2386
            dest_y -= s->linesize*15;
2387 2388
            dest_cb-= s->uvlinesize*7;
            dest_cr-= s->uvlinesize*7;
michaelni's avatar
michaelni committed
2389
        }
lorenm's avatar
lorenm committed
2390 2391
        if(FRAME_MBAFF) {
            int list;
2392
            for(list=0; list<h->list_count; list++){
lorenm's avatar
lorenm committed
2393 2394 2395 2396
                if(!USES_LIST(mb_type, list))
                    continue;
                if(IS_16X16(mb_type)){
                    int8_t *ref = &h->ref_cache[list][scan8[0]];
andoma's avatar
andoma committed
2397
                    fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
lorenm's avatar
lorenm committed
2398 2399 2400 2401
                }else{
                    for(i=0; i<16; i+=4){
                        int ref = h->ref_cache[list][scan8[i]];
                        if(ref >= 0)
andoma's avatar
andoma committed
2402
                            fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
lorenm's avatar
lorenm committed
2403 2404 2405 2406
                    }
                }
            }
        }
michaelni's avatar
michaelni committed
2407
    } else {
lorenm's avatar
lorenm committed
2408 2409
        linesize   = h->mb_linesize   = s->linesize;
        uvlinesize = h->mb_uvlinesize = s->uvlinesize;
michaelni's avatar
michaelni committed
2410 2411
//        dct_offset = s->linesize * 16;
    }
2412

2413
    if (!simple && IS_INTRA_PCM(mb_type)) {
michael's avatar
michael committed
2414 2415
        for (i=0; i<16; i++) {
            memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);
2416
        }
michael's avatar
michael committed
2417 2418 2419
        for (i=0; i<8; i++) {
            memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
            memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
2420
        }
2421 2422
    } else {
        if(IS_INTRA(mb_type)){
2423
            if(h->deblocking_filter)
2424
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple);
2425

michael's avatar
michael committed
2426
            if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2427 2428
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
                h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
2429
            }
michaelni's avatar
michaelni committed
2430

2431
            if(IS_INTRA4x4(mb_type)){
2432
                if(simple || !s->encoding){
lorenm's avatar
lorenm committed
2433
                    if(IS_8x8DCT(mb_type)){
2434 2435 2436
                        if(transform_bypass){
                            idct_dc_add =
                            idct_add    = s->dsp.add_pixels8;
2437
                        }else{
2438 2439 2440
                            idct_dc_add = s->dsp.h264_idct8_dc_add;
                            idct_add    = s->dsp.h264_idct8_add;
                        }
lorenm's avatar
lorenm committed
2441 2442 2443
                        for(i=0; i<16; i+=4){
                            uint8_t * const ptr= dest_y + block_offset[i];
                            const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
michael's avatar
michael committed
2444 2445 2446
                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
                                h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize);
                            }else{
2447 2448 2449 2450 2451 2452 2453 2454 2455
                                const int nnz = h->non_zero_count_cache[ scan8[i] ];
                                h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
                                                            (h->topright_samples_available<<i)&0x4000, linesize);
                                if(nnz){
                                    if(nnz == 1 && h->mb[i*16])
                                        idct_dc_add(ptr, h->mb + i*16, linesize);
                                    else
                                        idct_add   (ptr, h->mb + i*16, linesize);
                                }
michael's avatar
michael committed
2456
                            }
lorenm's avatar
lorenm committed
2457
                        }
2458 2459 2460 2461 2462 2463 2464 2465
                    }else{
                        if(transform_bypass){
                            idct_dc_add =
                            idct_add    = s->dsp.add_pixels4;
                        }else{
                            idct_dc_add = s->dsp.h264_idct_dc_add;
                            idct_add    = s->dsp.h264_idct_add;
                        }
2466
                    for(i=0; i<16; i++){
2467
                        uint8_t * const ptr= dest_y + block_offset[i];
2468 2469
                        const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];

michael's avatar
michael committed
2470 2471 2472
                        if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
                            h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
                        }else{
2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
                            uint8_t *topright;
                            int nnz, tr;
                            if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
                                const int topright_avail= (h->topright_samples_available<<i)&0x8000;
                                assert(mb_y || linesize <= block_offset[i]);
                                if(!topright_avail){
                                    tr= ptr[3 - linesize]*0x01010101;
                                    topright= (uint8_t*) &tr;
                                }else
                                    topright= ptr + 4 - linesize;
2483
                            }else
2484
                                topright= NULL;
2485

2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496
                            h->hpc.pred4x4[ dir ](ptr, topright, linesize);
                            nnz = h->non_zero_count_cache[ scan8[i] ];
                            if(nnz){
                                if(is_h264){
                                    if(nnz == 1 && h->mb[i*16])
                                        idct_dc_add(ptr, h->mb + i*16, linesize);
                                    else
                                        idct_add   (ptr, h->mb + i*16, linesize);
                                }else
                                    svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
                            }
michael's avatar
michael committed
2497
                        }
michaelni's avatar
michaelni committed
2498
                    }
2499
                    }
michaelni's avatar
michaelni committed
2500
                }
2501
            }else{
2502
                h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
2503
                if(is_h264){
lorenm's avatar
lorenm committed
2504
                    if(!transform_bypass)
takis's avatar
takis committed
2505
                        h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
lorenm's avatar
lorenm committed
2506
                }else
2507
                    svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
michaelni's avatar
michaelni committed
2508
            }
2509
            if(h->deblocking_filter)
2510
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
2511
        }else if(is_h264){
2512
            hl_motion(h, dest_y, dest_cb, dest_cr,
2513 2514
                      s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
                      s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2515
                      s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
michaelni's avatar
michaelni committed
2516
        }
2517 2518 2519


        if(!IS_INTRA4x4(mb_type)){
2520
            if(is_h264){
2521
                if(IS_INTRA16x16(mb_type)){
2522 2523
                    if(transform_bypass){
                        if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
michael's avatar
michael committed
2524 2525 2526 2527
                            h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
                        }else{
                            for(i=0; i<16; i++){
                                if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
2528
                                    s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize);
michael's avatar
michael committed
2529
                            }
2530 2531 2532
                        }
                    }else{
                         s->dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
michael's avatar
michael committed
2533
                    }
2534
                }else if(h->cbp&15){
2535
                    if(transform_bypass){
michael's avatar
michael committed
2536
                        const int di = IS_8x8DCT(mb_type) ? 4 : 1;
2537
                        idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
michael's avatar
michael committed
2538
                        for(i=0; i<16; i+=di){
michael's avatar
michael committed
2539
                            if(h->non_zero_count_cache[ scan8[i] ]){
2540
                                idct_add(dest_y + block_offset[i], h->mb + i*16, linesize);
michael's avatar
michael committed
2541
                            }
2542
                        }
2543 2544 2545 2546 2547 2548 2549
                    }else{
                        if(IS_8x8DCT(mb_type)){
                            s->dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
                        }else{
                            s->dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
                        }
                    }
michaelni's avatar
michaelni committed
2550
                }
2551 2552 2553
            }else{
                for(i=0; i<16; i++){
                    if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
2554
                        uint8_t * const ptr= dest_y + block_offset[i];
2555 2556
                        svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
                    }
michaelni's avatar
michaelni committed
2557
                }
michaelni's avatar
michaelni committed
2558 2559 2560
            }
        }

2561
        if((simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
2562 2563 2564 2565 2566 2567
            uint8_t *dest[2] = {dest_cb, dest_cr};
            if(transform_bypass){
                idct_add = idct_dc_add = s->dsp.add_pixels4;
            }else{
                idct_add = s->dsp.h264_idct_add;
                idct_dc_add = s->dsp.h264_idct_dc_add;
2568 2569
                chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp[0], h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
                chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp[1], h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
lorenm's avatar
lorenm committed
2570
            }
2571
            if(is_h264){
michael's avatar
michael committed
2572 2573 2574 2575
                if(transform_bypass && IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize);
                    h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize);
                }else{
2576 2577 2578 2579 2580 2581
                    for(i=16; i<16+8; i++){
                        if(h->non_zero_count_cache[ scan8[i] ])
                            idct_add   (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
                        else if(h->mb[i*16])
                            idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
                    }
michael's avatar
michael committed
2582
                }
2583
            }else{
2584
                for(i=16; i<16+8; i++){
2585
                    if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
2586
                        uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
2587 2588
                        svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
                    }
michaelni's avatar
michaelni committed
2589
                }
michaelni's avatar
michaelni committed
2590 2591 2592
            }
        }
    }
2593
    if(h->deblocking_filter) {
2594 2595 2596 2597
        backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, simple);
        fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
        h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
        h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2598
        if (!simple && FRAME_MBAFF) {
2599
            filter_mb     (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2600
        } else {
2601
            filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2602
        }
2603
    }
michaelni's avatar
michaelni committed
2604 2605
}

2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
/**
 * Process a macroblock; this case avoids checks for expensive uncommon cases.
 */
static void hl_decode_mb_simple(H264Context *h){
    hl_decode_mb_internal(h, 1);
}

/**
 * Process a macroblock; this handles edge cases, such as interlacing.
 */
static void av_noinline hl_decode_mb_complex(H264Context *h){
    hl_decode_mb_internal(h, 0);
}

static void hl_decode_mb(H264Context *h){
    MpegEncContext * const s = &h->s;
2622
    const int mb_xy= h->mb_xy;
2623
    const int mb_type= s->current_picture.mb_type[mb_xy];
2624
    int is_complex = ENABLE_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2625

2626
    if(ENABLE_H264_ENCODER && !s->decode)
2627 2628 2629 2630 2631 2632 2633
        return;

    if (is_complex)
        hl_decode_mb_complex(h);
    else hl_decode_mb_simple(h);
}

2634
static void pic_as_field(Picture *pic, const int parity){
2635 2636
    int i;
    for (i = 0; i < 4; ++i) {
2637
        if (parity == PICT_BOTTOM_FIELD)
2638
            pic->data[i] += pic->linesize[i];
2639
        pic->reference = parity;
2640 2641
        pic->linesize[i] *= 2;
    }
2642
    pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
2643 2644 2645 2646 2647 2648 2649 2650
}

static int split_field_copy(Picture *dest, Picture *src,
                            int parity, int id_add){
    int match = !!(src->reference & parity);

    if (match) {
        *dest = *src;
2651
        if(parity != PICT_FRAME){
michael's avatar
michael committed
2652 2653 2654
            pic_as_field(dest, parity);
            dest->pic_id *= 2;
            dest->pic_id += id_add;
2655
        }
2656 2657 2658 2659 2660
    }

    return match;
}

2661 2662 2663
static int build_def_list(Picture *def, Picture **in, int len, int is_long, int sel){
    int i[2]={0};
    int index=0;
2664

2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676
    while(i[0]<len || i[1]<len){
        while(i[0]<len && !(in[ i[0] ] && (in[ i[0] ]->reference & sel)))
            i[0]++;
        while(i[1]<len && !(in[ i[1] ] && (in[ i[1] ]->reference & (sel^3))))
            i[1]++;
        if(i[0] < len){
            in[ i[0] ]->pic_id= is_long ? i[0] : in[ i[0] ]->frame_num;
            split_field_copy(&def[index++], in[ i[0]++ ], sel  , 1);
        }
        if(i[1] < len){
            in[ i[1] ]->pic_id= is_long ? i[1] : in[ i[1] ]->frame_num;
            split_field_copy(&def[index++], in[ i[1]++ ], sel^3, 0);
2677 2678 2679
        }
    }

2680
    return index;
2681 2682
}

2683 2684 2685
static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){
    int i, best_poc;
    int out_i= 0;
2686

2687 2688
    for(;;){
        best_poc= dir ? INT_MIN : INT_MAX;
2689

2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701
        for(i=0; i<len; i++){
            const int poc= src[i]->poc;
            if(((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)){
                best_poc= poc;
                sorted[out_i]= src[i];
            }
        }
        if(best_poc == (dir ? INT_MIN : INT_MAX))
            break;
        limit= sorted[out_i++]->poc - dir;
    }
    return out_i;
2702 2703
}

michaelni's avatar
michaelni committed
2704 2705 2706 2707 2708
/**
 * fills the default_ref_list.
 */
static int fill_default_ref_list(H264Context *h){
    MpegEncContext * const s = &h->s;
2709
    int i, len;
2710

2711
    if(h->slice_type_nos==FF_B_TYPE){
2712 2713 2714
        Picture *sorted[32];
        int cur_poc, list;
        int lens[2];
2715

2716 2717 2718 2719
        if(FIELD_PICTURE)
            cur_poc= s->current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ];
        else
            cur_poc= s->current_picture_ptr->poc;
2720

2721 2722 2723 2724 2725 2726 2727
        for(list= 0; list<2; list++){
            len= add_sorted(sorted    , h->short_ref, h->short_ref_count, cur_poc, 1^list);
            len+=add_sorted(sorted+len, h->short_ref, h->short_ref_count, cur_poc, 0^list);
            assert(len<=32);
            len= build_def_list(h->default_ref_list[list]    , sorted     , len, 0, s->picture_structure);
            len+=build_def_list(h->default_ref_list[list]+len, h->long_ref, 16 , 1, s->picture_structure);
            assert(len<=32);
2728

2729 2730 2731
            if(len < h->ref_count[list])
                memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len));
            lens[list]= len;
2732 2733
        }

2734 2735 2736 2737
        if(lens[0] == lens[1] && lens[1] > 1){
            for(i=0; h->default_ref_list[0][i].data[0] == h->default_ref_list[1][i].data[0] && i<lens[0]; i++);
            if(i == lens[0])
                FFSWAP(Picture, h->default_ref_list[1][0], h->default_ref_list[1][1]);
2738 2739
        }
    }else{
2740 2741 2742 2743 2744
        len = build_def_list(h->default_ref_list[0]    , h->short_ref, h->short_ref_count, 0, s->picture_structure);
        len+= build_def_list(h->default_ref_list[0]+len, h-> long_ref, 16                , 1, s->picture_structure);
        assert(len <= 32);
        if(len < h->ref_count[0])
            memset(&h->default_ref_list[0][len], 0, sizeof(Picture)*(h->ref_count[0] - len));
michaelni's avatar
michaelni committed
2745
    }
2746 2747
#ifdef TRACE
    for (i=0; i<h->ref_count[0]; i++) {
mbardiaux's avatar
mbardiaux committed
2748
        tprintf(h->s.avctx, "List0: %s fn:%d 0x%p\n", (h->default_ref_list[0][i].long_ref ? "LT" : "ST"), h->default_ref_list[0][i].pic_id, h->default_ref_list[0][i].data[0]);
2749
    }
2750
    if(h->slice_type_nos==FF_B_TYPE){
2751
        for (i=0; i<h->ref_count[1]; i++) {
2752
            tprintf(h->s.avctx, "List1: %s fn:%d 0x%p\n", (h->default_ref_list[1][i].long_ref ? "LT" : "ST"), h->default_ref_list[1][i].pic_id, h->default_ref_list[1][i].data[0]);
2753 2754 2755
        }
    }
#endif
michaelni's avatar
michaelni committed
2756 2757 2758
    return 0;
}

2759 2760 2761
static void print_short_term(H264Context *h);
static void print_long_term(H264Context *h);

2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785
/**
 * Extract structure information about the picture described by pic_num in
 * the current decoding context (frame or field). Note that pic_num is
 * picture number without wrapping (so, 0<=pic_num<max_pic_num).
 * @param pic_num picture number for which to extract structure information
 * @param structure one of PICT_XXX describing structure of picture
 *                      with pic_num
 * @return frame number (short term) or long term index of picture
 *         described by pic_num
 */
static int pic_num_extract(H264Context *h, int pic_num, int *structure){
    MpegEncContext * const s = &h->s;

    *structure = s->picture_structure;
    if(FIELD_PICTURE){
        if (!(pic_num & 1))
            /* opposite field */
            *structure ^= PICT_FRAME;
        pic_num >>= 1;
    }

    return pic_num;
}

michaelni's avatar
michaelni committed
2786 2787
static int decode_ref_pic_list_reordering(H264Context *h){
    MpegEncContext * const s = &h->s;
2788
    int list, index, pic_structure;
2789

2790 2791
    print_short_term(h);
    print_long_term(h);
2792

2793
    for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
2794 2795 2796 2797 2798 2799
        memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);

        if(get_bits1(&s->gb)){
            int pred= h->curr_pic_num;

            for(index=0; ; index++){
2800 2801
                unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
                unsigned int pic_id;
michaelni's avatar
michaelni committed
2802
                int i;
2803
                Picture *ref = NULL;
2804 2805

                if(reordering_of_pic_nums_idc==3)
2806
                    break;
2807

michaelni's avatar
michaelni committed
2808
                if(index >= h->ref_count[list]){
2809
                    av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
michaelni's avatar
michaelni committed
2810 2811
                    return -1;
                }
2812

michaelni's avatar
michaelni committed
2813 2814
                if(reordering_of_pic_nums_idc<3){
                    if(reordering_of_pic_nums_idc<2){
2815
                        const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
2816
                        int frame_num;
michaelni's avatar
michaelni committed
2817

2818
                        if(abs_diff_pic_num > h->max_pic_num){
2819
                            av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
michaelni's avatar
michaelni committed
2820 2821 2822 2823 2824 2825
                            return -1;
                        }

                        if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
                        else                                pred+= abs_diff_pic_num;
                        pred &= h->max_pic_num - 1;
2826

2827 2828
                        frame_num = pic_num_extract(h, pred, &pic_structure);

2829 2830
                        for(i= h->short_ref_count-1; i>=0; i--){
                            ref = h->short_ref[i];
2831
                            assert(ref->reference);
2832
                            assert(!ref->long_ref);
2833
                            if(
michael's avatar
michael committed
2834 2835
                                   ref->frame_num == frame_num &&
                                   (ref->reference & pic_structure)
2836
                              )
michaelni's avatar
michaelni committed
2837 2838
                                break;
                        }
2839
                        if(i>=0)
2840
                            ref->pic_id= pred;
michaelni's avatar
michaelni committed
2841
                    }else{
2842
                        int long_idx;
michaelni's avatar
michaelni committed
2843
                        pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
2844 2845 2846 2847

                        long_idx= pic_num_extract(h, pic_id, &pic_structure);

                        if(long_idx>31){
2848 2849 2850
                            av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n");
                            return -1;
                        }
2851 2852
                        ref = h->long_ref[long_idx];
                        assert(!(ref && !ref->reference));
michael's avatar
michael committed
2853
                        if(ref && (ref->reference & pic_structure)){
2854 2855 2856 2857 2858 2859
                            ref->pic_id= pic_id;
                            assert(ref->long_ref);
                            i=0;
                        }else{
                            i=-1;
                        }
michaelni's avatar
michaelni committed
2860 2861
                    }

2862
                    if (i < 0) {
2863
                        av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
michaelni's avatar
michaelni committed
2864
                        memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
2865 2866 2867 2868
                    } else {
                        for(i=index; i+1<h->ref_count[list]; i++){
                            if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
                                break;
2869 2870 2871 2872
                        }
                        for(; i > index; i--){
                            h->ref_list[list][i]= h->ref_list[list][i-1];
                        }
2873
                        h->ref_list[list][index]= *ref;
2874
                        if (FIELD_PICTURE){
2875
                            pic_as_field(&h->ref_list[list][index], pic_structure);
2876
                        }
michaelni's avatar
michaelni committed
2877
                    }
2878
                }else{
2879
                    av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
michaelni's avatar
michaelni committed
2880 2881 2882 2883 2884
                    return -1;
                }
            }
        }
    }
2885
    for(list=0; list<h->list_count; list++){
2886
        for(index= 0; index < h->ref_count[list]; index++){
2887 2888 2889 2890
            if(!h->ref_list[list][index].data[0]){
                av_log(h->s.avctx, AV_LOG_ERROR, "Missing reference picture\n");
                h->ref_list[list][index]= s->current_picture; //FIXME this is not a sensible solution
            }
2891 2892
        }
    }
2893 2894

    return 0;
michaelni's avatar
michaelni committed
2895 2896
}

2897
static void fill_mbaff_ref_list(H264Context *h){
lorenm's avatar
lorenm committed
2898
    int list, i, j;
2899
    for(list=0; list<2; list++){ //FIXME try list_count
lorenm's avatar
lorenm committed
2900 2901 2902 2903 2904 2905
        for(i=0; i<h->ref_count[list]; i++){
            Picture *frame = &h->ref_list[list][i];
            Picture *field = &h->ref_list[list][16+2*i];
            field[0] = *frame;
            for(j=0; j<3; j++)
                field[0].linesize[j] <<= 1;
2906
            field[0].reference = PICT_TOP_FIELD;
2907
            field[0].poc= field[0].field_poc[0];
lorenm's avatar
lorenm committed
2908 2909 2910
            field[1] = field[0];
            for(j=0; j<3; j++)
                field[1].data[j] += frame->linesize[j];
2911
            field[1].reference = PICT_BOTTOM_FIELD;
2912
            field[1].poc= field[1].field_poc[1];
lorenm's avatar
lorenm committed
2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929

            h->luma_weight[list][16+2*i] = h->luma_weight[list][16+2*i+1] = h->luma_weight[list][i];
            h->luma_offset[list][16+2*i] = h->luma_offset[list][16+2*i+1] = h->luma_offset[list][i];
            for(j=0; j<2; j++){
                h->chroma_weight[list][16+2*i][j] = h->chroma_weight[list][16+2*i+1][j] = h->chroma_weight[list][i][j];
                h->chroma_offset[list][16+2*i][j] = h->chroma_offset[list][16+2*i+1][j] = h->chroma_offset[list][i][j];
            }
        }
    }
    for(j=0; j<h->ref_count[1]; j++){
        for(i=0; i<h->ref_count[0]; i++)
            h->implicit_weight[j][16+2*i] = h->implicit_weight[j][16+2*i+1] = h->implicit_weight[j][i];
        memcpy(h->implicit_weight[16+2*j],   h->implicit_weight[j], sizeof(*h->implicit_weight));
        memcpy(h->implicit_weight[16+2*j+1], h->implicit_weight[j], sizeof(*h->implicit_weight));
    }
}

michaelni's avatar
michaelni committed
2930 2931 2932
static int pred_weight_table(H264Context *h){
    MpegEncContext * const s = &h->s;
    int list, i;
lorenm's avatar
lorenm committed
2933
    int luma_def, chroma_def;
2934

lorenm's avatar
lorenm committed
2935 2936
    h->use_weight= 0;
    h->use_weight_chroma= 0;
michaelni's avatar
michaelni committed
2937 2938
    h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
    h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
lorenm's avatar
lorenm committed
2939 2940
    luma_def = 1<<h->luma_log2_weight_denom;
    chroma_def = 1<<h->chroma_log2_weight_denom;
michaelni's avatar
michaelni committed
2941 2942 2943 2944

    for(list=0; list<2; list++){
        for(i=0; i<h->ref_count[list]; i++){
            int luma_weight_flag, chroma_weight_flag;
2945

michaelni's avatar
michaelni committed
2946 2947 2948 2949
            luma_weight_flag= get_bits1(&s->gb);
            if(luma_weight_flag){
                h->luma_weight[list][i]= get_se_golomb(&s->gb);
                h->luma_offset[list][i]= get_se_golomb(&s->gb);
lorenm's avatar
lorenm committed
2950 2951 2952 2953 2954 2955
                if(   h->luma_weight[list][i] != luma_def
                   || h->luma_offset[list][i] != 0)
                    h->use_weight= 1;
            }else{
                h->luma_weight[list][i]= luma_def;
                h->luma_offset[list][i]= 0;
michaelni's avatar
michaelni committed
2956 2957
            }

2958
            if(CHROMA){
michael's avatar
michael committed
2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974
                chroma_weight_flag= get_bits1(&s->gb);
                if(chroma_weight_flag){
                    int j;
                    for(j=0; j<2; j++){
                        h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
                        h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
                        if(   h->chroma_weight[list][i][j] != chroma_def
                        || h->chroma_offset[list][i][j] != 0)
                            h->use_weight_chroma= 1;
                    }
                }else{
                    int j;
                    for(j=0; j<2; j++){
                        h->chroma_weight[list][i][j]= chroma_def;
                        h->chroma_offset[list][i][j]= 0;
                    }
michaelni's avatar
michaelni committed
2975 2976 2977
                }
            }
        }
2978
        if(h->slice_type_nos != FF_B_TYPE) break;
michaelni's avatar
michaelni committed
2979
    }
lorenm's avatar
lorenm committed
2980
    h->use_weight= h->use_weight || h->use_weight_chroma;
michaelni's avatar
michaelni committed
2981 2982 2983
    return 0;
}

lorenm's avatar
lorenm committed
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003
static void implicit_weight_table(H264Context *h){
    MpegEncContext * const s = &h->s;
    int ref0, ref1;
    int cur_poc = s->current_picture_ptr->poc;

    if(   h->ref_count[0] == 1 && h->ref_count[1] == 1
       && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
        h->use_weight= 0;
        h->use_weight_chroma= 0;
        return;
    }

    h->use_weight= 2;
    h->use_weight_chroma= 2;
    h->luma_log2_weight_denom= 5;
    h->chroma_log2_weight_denom= 5;

    for(ref0=0; ref0 < h->ref_count[0]; ref0++){
        int poc0 = h->ref_list[0][ref0].poc;
        for(ref1=0; ref1 < h->ref_count[1]; ref1++){
lorenm's avatar
lorenm committed
3004
            int poc1 = h->ref_list[1][ref1].poc;
reimar's avatar
reimar committed
3005
            int td = av_clip(poc1 - poc0, -128, 127);
lorenm's avatar
lorenm committed
3006
            if(td){
reimar's avatar
reimar committed
3007
                int tb = av_clip(cur_poc - poc0, -128, 127);
diego's avatar
diego committed
3008
                int tx = (16384 + (FFABS(td) >> 1)) / td;
reimar's avatar
reimar committed
3009
                int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
lorenm's avatar
lorenm committed
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019
                if(dist_scale_factor < -64 || dist_scale_factor > 128)
                    h->implicit_weight[ref0][ref1] = 32;
                else
                    h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
            }else
                h->implicit_weight[ref0][ref1] = 32;
        }
    }
}

3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
/**
 * Mark a picture as no longer needed for reference. The refmask
 * argument allows unreferencing of individual fields or the whole frame.
 * If the picture becomes entirely unreferenced, but is being held for
 * display purposes, it is marked as such.
 * @param refmask mask of fields to unreference; the mask is bitwise
 *                anded with the reference marking of pic
 * @return non-zero if pic becomes entirely unreferenced (except possibly
 *         for display purposes) zero if one of the fields remains in
 *         reference
 */
static inline int unreference_pic(H264Context *h, Picture *pic, int refmask){
3032
    int i;
3033 3034 3035
    if (pic->reference &= refmask) {
        return 0;
    } else {
michael's avatar
michael committed
3036 3037 3038 3039 3040
        for(i = 0; h->delayed_pic[i]; i++)
            if(pic == h->delayed_pic[i]){
                pic->reference=DELAYED_PIC_REF;
                break;
            }
3041 3042
        return 1;
    }
3043 3044
}

michaelni's avatar
michaelni committed
3045
/**
michael's avatar
michael committed
3046
 * instantaneous decoder refresh.
michaelni's avatar
michaelni committed
3047 3048
 */
static void idr(H264Context *h){
3049
    int i;
michaelni's avatar
michaelni committed
3050

3051
    for(i=0; i<16; i++){
3052
        remove_long(h, i, 0);
michaelni's avatar
michaelni committed
3053
    }
3054
    assert(h->long_ref_count==0);
michaelni's avatar
michaelni committed
3055 3056

    for(i=0; i<h->short_ref_count; i++){
3057
        unreference_pic(h, h->short_ref[i], 0);
michaelni's avatar
michaelni committed
3058 3059 3060
        h->short_ref[i]= NULL;
    }
    h->short_ref_count=0;
3061
    h->prev_frame_num= 0;
michael's avatar
michael committed
3062 3063 3064
    h->prev_frame_num_offset= 0;
    h->prev_poc_msb=
    h->prev_poc_lsb= 0;
michaelni's avatar
michaelni committed
3065 3066
}

lorenm's avatar
lorenm committed
3067 3068 3069 3070
/* forget old pics after a seek */
static void flush_dpb(AVCodecContext *avctx){
    H264Context *h= avctx->priv_data;
    int i;
3071
    for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
lorenm's avatar
lorenm committed
3072 3073
        if(h->delayed_pic[i])
            h->delayed_pic[i]->reference= 0;
lorenm's avatar
lorenm committed
3074
        h->delayed_pic[i]= NULL;
lorenm's avatar
lorenm committed
3075
    }
3076
    h->outputed_poc= INT_MIN;
lorenm's avatar
lorenm committed
3077
    idr(h);
3078 3079
    if(h->s.current_picture_ptr)
        h->s.current_picture_ptr->reference= 0;
3080
    h->s.first_field= 0;
3081
    ff_mpeg_flush(avctx);
lorenm's avatar
lorenm committed
3082 3083
}

michaelni's avatar
michaelni committed
3084
/**
3085 3086 3087 3088 3089 3090
 * Find a Picture in the short term reference list by frame number.
 * @param frame_num frame number to search for
 * @param idx the index into h->short_ref where returned picture is found
 *            undefined if no picture found.
 * @return pointer to the found picture, or NULL if no pic with the provided
 *                 frame number is found
michaelni's avatar
michaelni committed
3091
 */
3092
static Picture * find_short(H264Context *h, int frame_num, int *idx){
3093
    MpegEncContext * const s = &h->s;
michaelni's avatar
michaelni committed
3094
    int i;
3095

michaelni's avatar
michaelni committed
3096 3097
    for(i=0; i<h->short_ref_count; i++){
        Picture *pic= h->short_ref[i];
3098
        if(s->avctx->debug&FF_DEBUG_MMCO)
3099
            av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
3100 3101
        if(pic->frame_num == frame_num) {
            *idx = i;
michaelni's avatar
michaelni committed
3102 3103 3104 3105 3106 3107
            return pic;
        }
    }
    return NULL;
}

3108 3109 3110 3111 3112 3113 3114
/**
 * Remove a picture from the short term reference list by its index in
 * that list.  This does no checking on the provided index; it is assumed
 * to be valid. Other list entries are shifted down.
 * @param i index into h->short_ref of picture to remove.
 */
static void remove_short_at_index(H264Context *h, int i){
3115
    assert(i >= 0 && i < h->short_ref_count);
3116 3117 3118 3119 3120 3121 3122 3123 3124
    h->short_ref[i]= NULL;
    if (--h->short_ref_count)
        memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i)*sizeof(Picture*));
}

/**
 *
 * @return the removed picture or NULL if an error occurs
 */
3125
static Picture * remove_short(H264Context *h, int frame_num, int ref_mask){
3126 3127 3128 3129 3130 3131 3132 3133
    MpegEncContext * const s = &h->s;
    Picture *pic;
    int i;

    if(s->avctx->debug&FF_DEBUG_MMCO)
        av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);

    pic = find_short(h, frame_num, &i);
3134 3135
    if (pic){
        if(unreference_pic(h, pic, ref_mask))
3136
        remove_short_at_index(h, i);
3137
    }
3138 3139 3140 3141

    return pic;
}

3142 3143
/**
 * Remove a picture from the long term reference list by its index in
3144
 * that list.
3145
 * @return the removed picture or NULL if an error occurs
michaelni's avatar
michaelni committed
3146
 */
3147
static Picture * remove_long(H264Context *h, int i, int ref_mask){
michaelni's avatar
michaelni committed
3148 3149 3150
    Picture *pic;

    pic= h->long_ref[i];
3151
    if (pic){
3152 3153 3154 3155 3156 3157
        if(unreference_pic(h, pic, ref_mask)){
            assert(h->long_ref[i]->long_ref == 1);
            h->long_ref[i]->long_ref= 0;
            h->long_ref[i]= NULL;
            h->long_ref_count--;
        }
3158
    }
michaelni's avatar
michaelni committed
3159 3160 3161 3162

    return pic;
}

3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192
/**
 * print short term list
 */
static void print_short_term(H264Context *h) {
    uint32_t i;
    if(h->s.avctx->debug&FF_DEBUG_MMCO) {
        av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");
        for(i=0; i<h->short_ref_count; i++){
            Picture *pic= h->short_ref[i];
            av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
        }
    }
}

/**
 * print long term list
 */
static void print_long_term(H264Context *h) {
    uint32_t i;
    if(h->s.avctx->debug&FF_DEBUG_MMCO) {
        av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");
        for(i = 0; i < 16; i++){
            Picture *pic= h->long_ref[i];
            if (pic) {
                av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
            }
        }
    }
}

michaelni's avatar
michaelni committed
3193 3194 3195 3196 3197
/**
 * Executes the reference picture marking (memory management control operations).
 */
static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
    MpegEncContext * const s = &h->s;
3198
    int i, j;
3199
    int current_ref_assigned=0;
michaelni's avatar
michaelni committed
3200
    Picture *pic;
3201

michaelni's avatar
michaelni committed
3202
    if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
3203
        av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
3204

michaelni's avatar
michaelni committed
3205
    for(i=0; i<mmco_count; i++){
3206
        int structure, frame_num;
michaelni's avatar
michaelni committed
3207
        if(s->avctx->debug&FF_DEBUG_MMCO)
3208
            av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_pic_num, h->mmco[i].long_arg);
michaelni's avatar
michaelni committed
3209

3210 3211 3212 3213 3214
        if(   mmco[i].opcode == MMCO_SHORT2UNUSED
           || mmco[i].opcode == MMCO_SHORT2LONG){
            frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
            pic = find_short(h, frame_num, &j);
            if(!pic){
3215 3216
                if(mmco[i].opcode != MMCO_SHORT2LONG || !h->long_ref[mmco[i].long_arg]
                   || h->long_ref[mmco[i].long_arg]->frame_num != frame_num)
3217 3218 3219 3220 3221
                av_log(h->s.avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
                continue;
            }
        }

michaelni's avatar
michaelni committed
3222 3223
        switch(mmco[i].opcode){
        case MMCO_SHORT2UNUSED:
3224 3225
            if(s->avctx->debug&FF_DEBUG_MMCO)
                av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n", h->mmco[i].short_pic_num, h->short_ref_count);
3226
            remove_short(h, frame_num, structure ^ PICT_FRAME);
michaelni's avatar
michaelni committed
3227 3228
            break;
        case MMCO_SHORT2LONG:
3229 3230
                if (h->long_ref[mmco[i].long_arg] != pic)
                    remove_long(h, mmco[i].long_arg, 0);
3231

3232 3233
                remove_short_at_index(h, j);
                h->long_ref[ mmco[i].long_arg ]= pic;
3234 3235 3236 3237
                if (h->long_ref[ mmco[i].long_arg ]){
                    h->long_ref[ mmco[i].long_arg ]->long_ref=1;
                    h->long_ref_count++;
                }
michaelni's avatar
michaelni committed
3238 3239
            break;
        case MMCO_LONG2UNUSED:
3240 3241 3242
            j = pic_num_extract(h, mmco[i].long_arg, &structure);
            pic = h->long_ref[j];
            if (pic) {
3243
                remove_long(h, j, structure ^ PICT_FRAME);
3244 3245
            } else if(s->avctx->debug&FF_DEBUG_MMCO)
                av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
michaelni's avatar
michaelni committed
3246 3247
            break;
        case MMCO_LONG:
3248
                    // Comment below left from previous code as it is an interresting note.
3249 3250
                    /* First field in pair is in short term list or
                     * at a different long term index.
3251
                     * This is not allowed; see 7.4.3.3, notes 2 and 3.
3252 3253 3254 3255
                     * Report the problem and keep the pair where it is,
                     * and mark this field valid.
                     */

3256
            if (h->long_ref[mmco[i].long_arg] != s->current_picture_ptr) {
3257
                remove_long(h, mmco[i].long_arg, 0);
3258

3259 3260 3261
                h->long_ref[ mmco[i].long_arg ]= s->current_picture_ptr;
                h->long_ref[ mmco[i].long_arg ]->long_ref=1;
                h->long_ref_count++;
3262
            }
3263

3264
            s->current_picture_ptr->reference |= s->picture_structure;
3265
            current_ref_assigned=1;
michaelni's avatar
michaelni committed
3266 3267
            break;
        case MMCO_SET_MAX_LONG:
3268
            assert(mmco[i].long_arg <= 16);
3269
            // just remove the long term which index is greater than new max
3270
            for(j = mmco[i].long_arg; j<16; j++){
3271
                remove_long(h, j, 0);
michaelni's avatar
michaelni committed
3272 3273 3274 3275
            }
            break;
        case MMCO_RESET:
            while(h->short_ref_count){
3276
                remove_short(h, h->short_ref[0]->frame_num, 0);
michaelni's avatar
michaelni committed
3277
            }
3278
            for(j = 0; j < 16; j++) {
3279
                remove_long(h, j, 0);
michaelni's avatar
michaelni committed
3280
            }
michael's avatar
michael committed
3281 3282 3283 3284 3285 3286
            s->current_picture_ptr->poc=
            s->current_picture_ptr->field_poc[0]=
            s->current_picture_ptr->field_poc[1]=
            h->poc_lsb=
            h->poc_msb=
            h->frame_num=
michael's avatar
michael committed
3287
            s->current_picture_ptr->frame_num= 0;
michaelni's avatar
michaelni committed
3288 3289 3290 3291
            break;
        default: assert(0);
        }
    }
3292

3293
    if (!current_ref_assigned) {
3294 3295 3296 3297
        /* Second field of complementary field pair; the first field of
         * which is already referenced. If short referenced, it
         * should be first entry in short_ref. If not, it must exist
         * in long_ref; trying to put it on the short list here is an
3298
         * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
         */
        if (h->short_ref_count && h->short_ref[0] == s->current_picture_ptr) {
            /* Just mark the second field valid */
            s->current_picture_ptr->reference = PICT_FRAME;
        } else if (s->current_picture_ptr->long_ref) {
            av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term reference "
                                             "assignment for second field "
                                             "in complementary field pair "
                                             "(first field is long term)\n");
        } else {
3309
            pic= remove_short(h, s->current_picture_ptr->frame_num, 0);
michael's avatar
michael committed
3310 3311 3312
            if(pic){
                av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
            }
3313

michael's avatar
michael committed
3314 3315
            if(h->short_ref_count)
                memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
3316

michael's avatar
michael committed
3317 3318 3319 3320
            h->short_ref[0]= s->current_picture_ptr;
            h->short_ref_count++;
            s->current_picture_ptr->reference |= s->picture_structure;
        }
michael's avatar
michael committed
3321
    }
3322

3323
    if (h->long_ref_count + h->short_ref_count > h->sps.ref_frame_count){
3324 3325 3326 3327 3328 3329 3330 3331 3332

        /* We have too many reference frames, probably due to corrupted
         * stream. Need to discard one frame. Prevents overrun of the
         * short_ref and long_ref buffers.
         */
        av_log(h->s.avctx, AV_LOG_ERROR,
               "number of reference frames exceeds max (probably "
               "corrupt input), discarding one\n");

michael's avatar
michael committed
3333
        if (h->long_ref_count && !h->short_ref_count) {
3334 3335 3336 3337 3338
            for (i = 0; i < 16; ++i)
                if (h->long_ref[i])
                    break;

            assert(i < 16);
3339
            remove_long(h, i, 0);
3340
        } else {
3341
            pic = h->short_ref[h->short_ref_count - 1];
3342
            remove_short(h, pic->frame_num, 0);
3343 3344 3345
        }
    }

3346 3347
    print_short_term(h);
    print_long_term(h);
3348
    return 0;
michaelni's avatar
michaelni committed
3349 3350
}

3351
static int decode_ref_pic_marking(H264Context *h, GetBitContext *gb){
michaelni's avatar
michaelni committed
3352 3353
    MpegEncContext * const s = &h->s;
    int i;
3354

3355
    h->mmco_index= 0;
michaelni's avatar
michaelni committed
3356
    if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
3357
        s->broken_link= get_bits1(gb) -1;
3358
        if(get_bits1(gb)){
michaelni's avatar
michaelni committed
3359
            h->mmco[0].opcode= MMCO_LONG;
3360
            h->mmco[0].long_arg= 0;
michaelni's avatar
michaelni committed
3361
            h->mmco_index= 1;
3362
        }
michaelni's avatar
michaelni committed
3363
    }else{
3364
        if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag
3365
            for(i= 0; i<MAX_MMCO_COUNT; i++) {
3366
                MMCOOpcode opcode= get_ue_golomb(gb);
michaelni's avatar
michaelni committed
3367 3368 3369

                h->mmco[i].opcode= opcode;
                if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
3370
                    h->mmco[i].short_pic_num= (h->curr_pic_num - get_ue_golomb(gb) - 1) & (h->max_pic_num - 1);
3371
/*                    if(h->mmco[i].short_pic_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_pic_num ] == NULL){
3372
                        av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);
michaelni's avatar
michaelni committed
3373 3374 3375 3376
                        return -1;
                    }*/
                }
                if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
3377
                    unsigned int long_arg= get_ue_golomb(gb);
3378
                    if(long_arg >= 32 || (long_arg >= 16 && !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE))){
3379
                        av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
michaelni's avatar
michaelni committed
3380 3381
                        return -1;
                    }
3382
                    h->mmco[i].long_arg= long_arg;
michaelni's avatar
michaelni committed
3383
                }
3384

3385
                if(opcode > (unsigned)MMCO_LONG){
3386
                    av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
michaelni's avatar
michaelni committed
3387 3388
                    return -1;
                }
3389 3390
                if(opcode == MMCO_END)
                    break;
michaelni's avatar
michaelni committed
3391 3392 3393 3394 3395
            }
            h->mmco_index= i;
        }else{
            assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);

3396
            if(h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count &&
3397
                    !(FIELD_PICTURE && !s->first_field && s->current_picture_ptr->reference)) {
michaelni's avatar
michaelni committed
3398
                h->mmco[0].opcode= MMCO_SHORT2UNUSED;
3399
                h->mmco[0].short_pic_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
michaelni's avatar
michaelni committed
3400
                h->mmco_index= 1;
3401 3402 3403 3404 3405 3406
                if (FIELD_PICTURE) {
                    h->mmco[0].short_pic_num *= 2;
                    h->mmco[1].opcode= MMCO_SHORT2UNUSED;
                    h->mmco[1].short_pic_num= h->mmco[0].short_pic_num + 1;
                    h->mmco_index= 2;
                }
michael's avatar
michael committed
3407
            }
michaelni's avatar
michaelni committed
3408 3409
        }
    }
3410 3411

    return 0;
michaelni's avatar
michaelni committed
3412 3413 3414 3415 3416 3417
}

static int init_poc(H264Context *h){
    MpegEncContext * const s = &h->s;
    const int max_frame_num= 1<<h->sps.log2_max_frame_num;
    int field_poc[2];
3418
    Picture *cur = s->current_picture_ptr;
michaelni's avatar
michaelni committed
3419

3420
    h->frame_num_offset= h->prev_frame_num_offset;
3421
    if(h->frame_num < h->prev_frame_num)
3422
        h->frame_num_offset += max_frame_num;
michaelni's avatar
michaelni committed
3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433

    if(h->sps.poc_type==0){
        const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;

        if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
            h->poc_msb = h->prev_poc_msb + max_poc_lsb;
        else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
            h->poc_msb = h->prev_poc_msb - max_poc_lsb;
        else
            h->poc_msb = h->prev_poc_msb;
//printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
3434
        field_poc[0] =
michaelni's avatar
michaelni committed
3435
        field_poc[1] = h->poc_msb + h->poc_lsb;
3436
        if(s->picture_structure == PICT_FRAME)
michaelni's avatar
michaelni committed
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448
            field_poc[1] += h->delta_poc_bottom;
    }else if(h->sps.poc_type==1){
        int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
        int i;

        if(h->sps.poc_cycle_length != 0)
            abs_frame_num = h->frame_num_offset + h->frame_num;
        else
            abs_frame_num = 0;

        if(h->nal_ref_idc==0 && abs_frame_num > 0)
            abs_frame_num--;
3449

michaelni's avatar
michaelni committed
3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
        expected_delta_per_poc_cycle = 0;
        for(i=0; i < h->sps.poc_cycle_length; i++)
            expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse

        if(abs_frame_num > 0){
            int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
            int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;

            expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
            for(i = 0; i <= frame_num_in_poc_cycle; i++)
                expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
        } else
            expectedpoc = 0;

3464
        if(h->nal_ref_idc == 0)
michaelni's avatar
michaelni committed
3465
            expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
3466

michaelni's avatar
michaelni committed
3467 3468 3469 3470 3471 3472
        field_poc[0] = expectedpoc + h->delta_poc[0];
        field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;

        if(s->picture_structure == PICT_FRAME)
            field_poc[1] += h->delta_poc[1];
    }else{
3473
        int poc= 2*(h->frame_num_offset + h->frame_num);
3474

3475 3476
        if(!h->nal_ref_idc)
            poc--;
3477

michaelni's avatar
michaelni committed
3478 3479 3480
        field_poc[0]= poc;
        field_poc[1]= poc;
    }
3481

3482
    if(s->picture_structure != PICT_BOTTOM_FIELD)
michaelni's avatar
michaelni committed
3483
        s->current_picture_ptr->field_poc[0]= field_poc[0];
3484
    if(s->picture_structure != PICT_TOP_FIELD)
michaelni's avatar
michaelni committed
3485
        s->current_picture_ptr->field_poc[1]= field_poc[1];
3486
    cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
michaelni's avatar
michaelni committed
3487 3488 3489 3490

    return 0;
}

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539

/**
 * initialize scan tables
 */
static void init_scan_tables(H264Context *h){
    MpegEncContext * const s = &h->s;
    int i;
    if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
        memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
        memcpy(h-> field_scan,  field_scan, 16*sizeof(uint8_t));
    }else{
        for(i=0; i<16; i++){
#define T(x) (x>>2) | ((x<<2) & 0xF)
            h->zigzag_scan[i] = T(zigzag_scan[i]);
            h-> field_scan[i] = T( field_scan[i]);
#undef T
        }
    }
    if(s->dsp.h264_idct8_add == ff_h264_idct8_add_c){
        memcpy(h->zigzag_scan8x8,       zigzag_scan8x8,       64*sizeof(uint8_t));
        memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t));
        memcpy(h->field_scan8x8,        field_scan8x8,        64*sizeof(uint8_t));
        memcpy(h->field_scan8x8_cavlc,  field_scan8x8_cavlc,  64*sizeof(uint8_t));
    }else{
        for(i=0; i<64; i++){
#define T(x) (x>>3) | ((x&7)<<3)
            h->zigzag_scan8x8[i]       = T(zigzag_scan8x8[i]);
            h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
            h->field_scan8x8[i]        = T(field_scan8x8[i]);
            h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);
#undef T
        }
    }
    if(h->sps.transform_bypass){ //FIXME same ugly
        h->zigzag_scan_q0          = zigzag_scan;
        h->zigzag_scan8x8_q0       = zigzag_scan8x8;
        h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
        h->field_scan_q0           = field_scan;
        h->field_scan8x8_q0        = field_scan8x8;
        h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
    }else{
        h->zigzag_scan_q0          = h->zigzag_scan;
        h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
        h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
        h->field_scan_q0           = h->field_scan;
        h->field_scan8x8_q0        = h->field_scan8x8;
        h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
    }
}
3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550

/**
 * Replicates H264 "master" context to thread contexts.
 */
static void clone_slice(H264Context *dst, H264Context *src)
{
    memcpy(dst->block_offset,     src->block_offset, sizeof(dst->block_offset));
    dst->s.current_picture_ptr  = src->s.current_picture_ptr;
    dst->s.current_picture      = src->s.current_picture;
    dst->s.linesize             = src->s.linesize;
    dst->s.uvlinesize           = src->s.uvlinesize;
3551
    dst->s.first_field          = src->s.first_field;
3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562

    dst->prev_poc_msb           = src->prev_poc_msb;
    dst->prev_poc_lsb           = src->prev_poc_lsb;
    dst->prev_frame_num_offset  = src->prev_frame_num_offset;
    dst->prev_frame_num         = src->prev_frame_num;
    dst->short_ref_count        = src->short_ref_count;

    memcpy(dst->short_ref,        src->short_ref,        sizeof(dst->short_ref));
    memcpy(dst->long_ref,         src->long_ref,         sizeof(dst->long_ref));
    memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
    memcpy(dst->ref_list,         src->ref_list,         sizeof(dst->ref_list));
3563 3564 3565

    memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
    memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
3566 3567
}

michaelni's avatar
michaelni committed
3568 3569
/**
 * decodes a slice header.
diego's avatar
diego committed
3570
 * This will also call MPV_common_init() and frame_start() as needed.
3571 3572 3573 3574
 *
 * @param h h264context
 * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
 *
diego's avatar
diego committed
3575
 * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
michaelni's avatar
michaelni committed
3576
 */
3577
static int decode_slice_header(H264Context *h, H264Context *h0){
michaelni's avatar
michaelni committed
3578
    MpegEncContext * const s = &h->s;
3579
    MpegEncContext * const s0 = &h0->s;
3580
    unsigned int first_mb_in_slice;
3581
    unsigned int pps_id;
michaelni's avatar
michaelni committed
3582
    int num_ref_idx_active_override_flag;
3583
    unsigned int slice_type, tmp, i, j;
3584
    int default_ref_list_done = 0;
3585
    int last_pic_structure;
michaelni's avatar
michaelni committed
3586

3587
    s->dropable= h->nal_ref_idc == 0;
michaelni's avatar
michaelni committed
3588

3589 3590 3591 3592 3593 3594 3595 3596
    if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){
        s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
        s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
    }else{
        s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
        s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
    }

michaelni's avatar
michaelni committed
3597 3598
    first_mb_in_slice= get_ue_golomb(&s->gb);

3599
    if((s->flags2 & CODEC_FLAG2_CHUNKS) && first_mb_in_slice == 0){
3600
        h0->current_slice = 0;
3601
        if (!s0->first_field)
andoma's avatar
andoma committed
3602
            s->current_picture_ptr= NULL;
3603 3604
    }

3605 3606
    slice_type= get_ue_golomb(&s->gb);
    if(slice_type > 9){
3607
        av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y);
michael's avatar
michael committed
3608
        return -1;
michaelni's avatar
michaelni committed
3609
    }
3610 3611
    if(slice_type > 4){
        slice_type -= 5;
michaelni's avatar
michaelni committed
3612 3613 3614
        h->slice_type_fixed=1;
    }else
        h->slice_type_fixed=0;
3615

3616
    slice_type= golomb_to_pict_type[ slice_type ];
3617
    if (slice_type == FF_I_TYPE
3618
        || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
3619 3620 3621
        default_ref_list_done = 1;
    }
    h->slice_type= slice_type;
michael's avatar
michael committed
3622
    h->slice_type_nos= slice_type & 3;
3623

diego's avatar
diego committed
3624
    s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
3625
    if (s->pict_type == FF_B_TYPE && s0->last_picture_ptr == NULL) {
3626 3627 3628 3629
        av_log(h->s.avctx, AV_LOG_ERROR,
               "B picture before any references, skipping\n");
        return -1;
    }
3630

michaelni's avatar
michaelni committed
3631
    pps_id= get_ue_golomb(&s->gb);
3632
    if(pps_id>=MAX_PPS_COUNT){
3633
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
michaelni's avatar
michaelni committed
3634 3635
        return -1;
    }
3636
    if(!h0->pps_buffers[pps_id]) {
diego's avatar
diego committed
3637
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS referenced\n");
michaelni's avatar
michaelni committed
3638 3639
        return -1;
    }
3640
    h->pps= *h0->pps_buffers[pps_id];
michaelni's avatar
michaelni committed
3641

3642
    if(!h0->sps_buffers[h->pps.sps_id]) {
diego's avatar
diego committed
3643
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS referenced\n");
michaelni's avatar
michaelni committed
3644 3645
        return -1;
    }
3646
    h->sps = *h0->sps_buffers[h->pps.sps_id];
lorenm's avatar
lorenm committed
3647

3648
    if(h == h0 && h->dequant_coeff_pps != pps_id){
3649
        h->dequant_coeff_pps = pps_id;
lorenm's avatar
lorenm committed
3650 3651
        init_dequant_tables(h);
    }
3652

michaelni's avatar
michaelni committed
3653
    s->mb_width= h->sps.mb_width;
3654
    s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
3655

3656 3657
    h->b_stride=  s->mb_width*4;
    h->b8_stride= s->mb_width*2;
michaelni's avatar
michaelni committed
3658

3659
    s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
michaelni's avatar
michaelni committed
3660
    if(h->sps.frame_mbs_only_flag)
3661
        s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
michaelni's avatar
michaelni committed
3662
    else
3663
        s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 3);
3664 3665

    if (s->context_initialized
michael's avatar
michael committed
3666
        && (   s->width != s->avctx->width || s->height != s->avctx->height)) {
3667 3668
        if(h != h0)
            return -1;   // width / height changed during parallelized decoding
michaelni's avatar
michaelni committed
3669
        free_tables(h);
3670
        flush_dpb(s->avctx);
michaelni's avatar
michaelni committed
3671 3672 3673
        MPV_common_end(s);
    }
    if (!s->context_initialized) {
3674 3675
        if(h != h0)
            return -1;  // we cant (re-)initialize context during parallel decoding
michaelni's avatar
michaelni committed
3676 3677
        if (MPV_common_init(s) < 0)
            return -1;
3678
        s->first_field = 0;
3679

3680
        init_scan_tables(h);
michaelni's avatar
michaelni committed
3681 3682
        alloc_tables(h);

3683 3684 3685
        for(i = 1; i < s->avctx->thread_count; i++) {
            H264Context *c;
            c = h->thread_context[i] = av_malloc(sizeof(H264Context));
3686
            memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697
            memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
            c->sps = h->sps;
            c->pps = h->pps;
            init_scan_tables(c);
            clone_tables(c, h);
        }

        for(i = 0; i < s->avctx->thread_count; i++)
            if(context_init(h->thread_context[i]) < 0)
                return -1;

michaelni's avatar
michaelni committed
3698 3699
        s->avctx->width = s->width;
        s->avctx->height = s->height;
michael's avatar
michael committed
3700
        s->avctx->sample_aspect_ratio= h->sps.sar;
michael's avatar
michael committed
3701 3702
        if(!s->avctx->sample_aspect_ratio.den)
            s->avctx->sample_aspect_ratio.den = 1;
3703

michael's avatar
michael committed
3704
        if(h->sps.timing_info_present_flag){
3705
            s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
3706 3707 3708 3709
            if(h->x264_build > 0 && h->x264_build < 44)
                s->avctx->time_base.den *= 2;
            av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
                      s->avctx->time_base.num, s->avctx->time_base.den, 1<<30);
3710
        }
michaelni's avatar
michaelni committed
3711 3712 3713 3714
    }

    h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);

lorenm's avatar
lorenm committed
3715
    h->mb_mbaff = 0;
3716
    h->mb_aff_frame = 0;
3717
    last_pic_structure = s0->picture_structure;
michaelni's avatar
michaelni committed
3718 3719 3720
    if(h->sps.frame_mbs_only_flag){
        s->picture_structure= PICT_FRAME;
    }else{
3721
        if(get_bits1(&s->gb)) { //field_pic_flag
michaelni's avatar
michaelni committed
3722
            s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
3723
        } else {
michaelni's avatar
michaelni committed
3724
            s->picture_structure= PICT_FRAME;
3725
            h->mb_aff_frame = h->sps.mb_aff;
3726
        }
michaelni's avatar
michaelni committed
3727
    }
3728
    h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
3729 3730

    if(h0->current_slice == 0){
michael's avatar
michael committed
3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
        while(h->frame_num !=  h->prev_frame_num &&
              h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
            av_log(NULL, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);
            frame_start(h);
            h->prev_frame_num++;
            h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
            s->current_picture_ptr->frame_num= h->prev_frame_num;
            execute_ref_pic_marking(h, NULL, 0);
        }

3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782
        /* See if we have a decoded first field looking for a pair... */
        if (s0->first_field) {
            assert(s0->current_picture_ptr);
            assert(s0->current_picture_ptr->data[0]);
            assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);

            /* figure out if we have a complementary field pair */
            if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
                /*
                 * Previous field is unmatched. Don't display it, but let it
                 * remain for reference if marked as such.
                 */
                s0->current_picture_ptr = NULL;
                s0->first_field = FIELD_PICTURE;

            } else {
                if (h->nal_ref_idc &&
                        s0->current_picture_ptr->reference &&
                        s0->current_picture_ptr->frame_num != h->frame_num) {
                    /*
                     * This and previous field were reference, but had
                     * different frame_nums. Consider this field first in
                     * pair. Throw away previous field except for reference
                     * purposes.
                     */
                    s0->first_field = 1;
                    s0->current_picture_ptr = NULL;

                } else {
                    /* Second field in complementary pair */
                    s0->first_field = 0;
                }
            }

        } else {
            /* Frame or first field in a potentially complementary pair */
            assert(!s0->current_picture_ptr);
            s0->first_field = FIELD_PICTURE;
        }

        if((!FIELD_PICTURE || s0->first_field) && frame_start(h) < 0) {
            s0->first_field = 0;
3783
            return -1;
3784
        }
3785 3786 3787 3788 3789 3790
    }
    if(h != h0)
        clone_slice(h, h0);

    s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup

3791
    assert(s->mb_num == s->mb_width * s->mb_height);
3792
    if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
3793 3794
       first_mb_in_slice                    >= s->mb_num){
        av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
michael's avatar
michael committed
3795 3796
        return -1;
    }
3797
    s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
3798 3799 3800
    s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
    if (s->picture_structure == PICT_BOTTOM_FIELD)
        s->resync_mb_y = s->mb_y = s->mb_y + 1;
3801
    assert(s->mb_y < s->mb_height);
3802

michaelni's avatar
michaelni committed
3803 3804 3805 3806
    if(s->picture_structure==PICT_FRAME){
        h->curr_pic_num=   h->frame_num;
        h->max_pic_num= 1<< h->sps.log2_max_frame_num;
    }else{
3807
        h->curr_pic_num= 2*h->frame_num + 1;
michaelni's avatar
michaelni committed
3808 3809
        h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
    }
3810

michaelni's avatar
michaelni committed
3811
    if(h->nal_unit_type == NAL_IDR_SLICE){
bellard's avatar
bellard committed
3812
        get_ue_golomb(&s->gb); /* idr_pic_id */
michaelni's avatar
michaelni committed
3813
    }
3814

michaelni's avatar
michaelni committed
3815 3816
    if(h->sps.poc_type==0){
        h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
3817

michaelni's avatar
michaelni committed
3818 3819 3820 3821
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
            h->delta_poc_bottom= get_se_golomb(&s->gb);
        }
    }
3822

michaelni's avatar
michaelni committed
3823 3824
    if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
        h->delta_poc[0]= get_se_golomb(&s->gb);
3825

michaelni's avatar
michaelni committed
3826 3827 3828
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
            h->delta_poc[1]= get_se_golomb(&s->gb);
    }
3829

michaelni's avatar
michaelni committed
3830
    init_poc(h);
3831

michaelni's avatar
michaelni committed
3832 3833 3834 3835
    if(h->pps.redundant_pic_cnt_present){
        h->redundant_pic_count= get_ue_golomb(&s->gb);
    }

diego's avatar
diego committed
3836
    //set defaults, might be overridden a few lines later
michaelni's avatar
michaelni committed
3837 3838 3839
    h->ref_count[0]= h->pps.ref_count[0];
    h->ref_count[1]= h->pps.ref_count[1];

michael's avatar
michael committed
3840
    if(h->slice_type_nos != FF_I_TYPE){
3841
        if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
3842 3843 3844
            h->direct_spatial_mv_pred= get_bits1(&s->gb);
        }
        num_ref_idx_active_override_flag= get_bits1(&s->gb);
3845

michaelni's avatar
michaelni committed
3846 3847
        if(num_ref_idx_active_override_flag){
            h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
3848
            if(h->slice_type_nos==FF_B_TYPE)
michaelni's avatar
michaelni committed
3849 3850
                h->ref_count[1]= get_ue_golomb(&s->gb) + 1;

michael's avatar
michael committed
3851
            if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
3852
                av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
3853
                h->ref_count[0]= h->ref_count[1]= 1;
michaelni's avatar
michaelni committed
3854 3855 3856
                return -1;
            }
        }
3857
        if(h->slice_type_nos == FF_B_TYPE)
michael's avatar
michael committed
3858 3859 3860 3861 3862
            h->list_count= 2;
        else
            h->list_count= 1;
    }else
        h->list_count= 0;
michaelni's avatar
michaelni committed
3863

3864
    if(!default_ref_list_done){
michaelni's avatar
michaelni committed
3865 3866 3867
        fill_default_ref_list(h);
    }

3868
    if(h->slice_type_nos!=FF_I_TYPE && decode_ref_pic_list_reordering(h) < 0)
3869
        return -1;
michaelni's avatar
michaelni committed
3870

3871 3872
    if(h->slice_type_nos!=FF_I_TYPE){
        s->last_picture_ptr= &h->ref_list[0][0];
3873
        ff_copy_picture(&s->last_picture, s->last_picture_ptr);
3874 3875 3876
    }
    if(h->slice_type_nos==FF_B_TYPE){
        s->next_picture_ptr= &h->ref_list[1][0];
3877
        ff_copy_picture(&s->next_picture, s->next_picture_ptr);
3878 3879
    }

michael's avatar
michael committed
3880
    if(   (h->pps.weighted_pred          && h->slice_type_nos == FF_P_TYPE )
3881
       ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) )
michaelni's avatar
michaelni committed
3882
        pred_weight_table(h);
3883
    else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE)
lorenm's avatar
lorenm committed
3884 3885 3886
        implicit_weight_table(h);
    else
        h->use_weight = 0;
3887

3888
    if(h->nal_ref_idc)
3889
        decode_ref_pic_marking(h0, &s->gb);
michaelni's avatar
michaelni committed
3890

lorenm's avatar
lorenm committed
3891 3892 3893
    if(FRAME_MBAFF)
        fill_mbaff_ref_list(h);

3894 3895 3896 3897
    if(h->slice_type_nos==FF_B_TYPE && !h->direct_spatial_mv_pred)
        direct_dist_scale_factor(h);
    direct_ref_list_init(h);

michael's avatar
michael committed
3898
    if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
3899 3900 3901 3902 3903 3904 3905
        tmp = get_ue_golomb(&s->gb);
        if(tmp > 2){
            av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
            return -1;
        }
        h->cabac_init_idc= tmp;
    }
3906 3907

    h->last_qscale_diff = 0;
3908 3909 3910
    tmp = h->pps.init_qp + get_se_golomb(&s->gb);
    if(tmp>51){
        av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
michael's avatar
michael committed
3911 3912
        return -1;
    }
3913
    s->qscale= tmp;
3914 3915
    h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
    h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
michaelni's avatar
michaelni committed
3916
    //FIXME qscale / qp ... stuff
3917
    if(h->slice_type == FF_SP_TYPE){
bellard's avatar
bellard committed
3918
        get_bits1(&s->gb); /* sp_for_switch_flag */
michaelni's avatar
michaelni committed
3919
    }
3920
    if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){
bellard's avatar
bellard committed
3921
        get_se_golomb(&s->gb); /* slice_qs_delta */
michaelni's avatar
michaelni committed
3922 3923
    }

3924
    h->deblocking_filter = 1;
michael's avatar
michael committed
3925 3926
    h->slice_alpha_c0_offset = 0;
    h->slice_beta_offset = 0;
michaelni's avatar
michaelni committed
3927
    if( h->pps.deblocking_filter_parameters_present ) {
3928 3929 3930 3931 3932 3933
        tmp= get_ue_golomb(&s->gb);
        if(tmp > 2){
            av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
            return -1;
        }
        h->deblocking_filter= tmp;
3934
        if(h->deblocking_filter < 2)
3935 3936 3937
            h->deblocking_filter^= 1; // 1<->0

        if( h->deblocking_filter ) {
3938 3939
            h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
            h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
michaelni's avatar
michaelni committed
3940
        }
3941
    }
3942

3943
    if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
3944
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE)
3945
       ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == FF_B_TYPE)
3946 3947 3948
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
        h->deblocking_filter= 0;

3949
    if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
3950 3951
        if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
            /* Cheat slightly for speed:
diego's avatar
diego committed
3952
               Do not bother to deblock across slices. */
3953 3954
            h->deblocking_filter = 2;
        } else {
benoit's avatar
benoit committed
3955 3956 3957 3958 3959 3960 3961
            h0->max_contexts = 1;
            if(!h0->single_decode_warning) {
                av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
                h0->single_decode_warning = 1;
            }
            if(h != h0)
                return 1; // deblocking switched inside frame
3962
        }
3963 3964
    }

michaelni's avatar
michaelni committed
3965 3966 3967 3968 3969
#if 0 //FMO
    if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
        slice_group_change_cycle= get_bits(&s->gb, ?);
#endif

3970 3971
    h0->last_slice_type = slice_type;
    h->slice_num = ++h0->current_slice;
3972 3973 3974
    if(h->slice_num >= MAX_SLICES){
        av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
    }
michael's avatar
michael committed
3975

3976
    for(j=0; j<2; j++){
3977
        int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
3978 3979
        ref2frm[0]=
        ref2frm[1]= -1;
3980
        for(i=0; i<16; i++)
3981 3982
            ref2frm[i+2]= 4*h->ref_list[j][i].frame_num
                          +(h->ref_list[j][i].reference&3);
3983 3984 3985 3986 3987
        ref2frm[18+0]=
        ref2frm[18+1]= -1;
        for(i=16; i<48; i++)
            ref2frm[i+4]= 4*h->ref_list[j][i].frame_num
                          +(h->ref_list[j][i].reference&3);
3988 3989
    }

lorenm's avatar
lorenm committed
3990
    h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16;
3991
    h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
lorenm's avatar
lorenm committed
3992

michaelni's avatar
michaelni committed
3993
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
3994
        av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
3995 3996
               h->slice_num,
               (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
3997
               first_mb_in_slice,
3998
               av_get_pict_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
michaelni's avatar
michaelni committed
3999 4000 4001 4002
               pps_id, h->frame_num,
               s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
               h->ref_count[0], h->ref_count[1],
               s->qscale,
4003
               h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
lorenm's avatar
lorenm committed
4004
               h->use_weight,
michael's avatar
michael committed
4005 4006
               h->use_weight==1 && h->use_weight_chroma ? "c" : "",
               h->slice_type == FF_B_TYPE ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
michaelni's avatar
michaelni committed
4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018
               );
    }

    return 0;
}

/**
 *
 */
static inline int get_level_prefix(GetBitContext *gb){
    unsigned int buf;
    int log;
4019

michaelni's avatar
michaelni committed
4020 4021 4022
    OPEN_READER(re, gb);
    UPDATE_CACHE(re, gb);
    buf=GET_CACHE(re, gb);
4023

michaelni's avatar
michaelni committed
4024 4025 4026
    log= 32 - av_log2(buf);
#ifdef TRACE
    print_bin(buf>>(32-log), log);
4027
    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
michaelni's avatar
michaelni committed
4028 4029 4030 4031 4032 4033 4034 4035
#endif

    LAST_SKIP_BITS(re, gb, log);
    CLOSE_READER(re, gb);

    return log-1;
}

lorenm's avatar
lorenm committed
4036 4037 4038 4039
static inline int get_dct8x8_allowed(H264Context *h){
    int i;
    for(i=0; i<4; i++){
        if(!IS_SUB_8X8(h->sub_mb_type[i])
4040
           || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
lorenm's avatar
lorenm committed
4041 4042 4043 4044 4045
            return 0;
    }
    return 1;
}

michaelni's avatar
michaelni committed
4046 4047 4048 4049 4050
/**
 * decodes a residual block.
 * @param n block index
 * @param scantable scantable
 * @param max_coeff number of coefficients in the block
diego's avatar
diego committed
4051
 * @return <0 if an error occurred
michaelni's avatar
michaelni committed
4052
 */
lorenm's avatar
lorenm committed
4053
static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
michaelni's avatar
michaelni committed
4054 4055
    MpegEncContext * const s = &h->s;
    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};
lorenm's avatar
lorenm committed
4056 4057
    int level[16];
    int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
michaelni's avatar
michaelni committed
4058 4059 4060 4061 4062 4063

    //FIXME put trailing_onex into the context

    if(n == CHROMA_DC_BLOCK_INDEX){
        coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
        total_coeff= coeff_token>>2;
4064
    }else{
michaelni's avatar
michaelni committed
4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080
        if(n == LUMA_DC_BLOCK_INDEX){
            total_coeff= pred_non_zero_count(h, 0);
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
            total_coeff= coeff_token>>2;
        }else{
            total_coeff= pred_non_zero_count(h, n);
            coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
            total_coeff= coeff_token>>2;
            h->non_zero_count_cache[ scan8[n] ]= total_coeff;
        }
    }

    //FIXME set last_non_zero?

    if(total_coeff==0)
        return 0;
4081 4082
    if(total_coeff > (unsigned)max_coeff) {
        av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
4083 4084
        return -1;
    }
4085

michaelni's avatar
michaelni committed
4086
    trailing_ones= coeff_token&3;
mbardiaux's avatar
mbardiaux committed
4087
    tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
michaelni's avatar
michaelni committed
4088
    assert(total_coeff<=16);
4089

4090 4091 4092 4093 4094
    i = show_bits(gb, 3);
    skip_bits(gb, trailing_ones);
    level[0] = 1-((i&4)>>1);
    level[1] = 1-((i&2)   );
    level[2] = 1-((i&1)<<1);
michaelni's avatar
michaelni committed
4095

4096
    if(trailing_ones<total_coeff) {
michaelni's avatar
michaelni committed
4097
        int level_code, mask;
lorenm's avatar
lorenm committed
4098 4099
        int suffix_length = total_coeff > 10 && trailing_ones < 3;
        int prefix= get_level_prefix(gb);
michaelni's avatar
michaelni committed
4100

lorenm's avatar
lorenm committed
4101
        //first coefficient has suffix_length equal to 0 or 1
michaelni's avatar
michaelni committed
4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
        if(prefix<14){ //FIXME try to build a large unified VLC table for all this
            if(suffix_length)
                level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
            else
                level_code= (prefix<<suffix_length); //part
        }else if(prefix==14){
            if(suffix_length)
                level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
            else
                level_code= prefix + get_bits(gb, 4); //part
        }else{
michael's avatar
michael committed
4113 4114 4115 4116
            level_code= (15<<suffix_length) + get_bits(gb, prefix-3); //part
            if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
            if(prefix>=16)
                level_code += (1<<(prefix-3))-4096;
michaelni's avatar
michaelni committed
4117 4118
        }

lorenm's avatar
lorenm committed
4119
        if(trailing_ones < 3) level_code += 2;
michaelni's avatar
michaelni committed
4120

lorenm's avatar
lorenm committed
4121 4122 4123
        suffix_length = 1;
        if(level_code > 5)
            suffix_length++;
michaelni's avatar
michaelni committed
4124
        mask= -(level_code&1);
4125
        level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
lorenm's avatar
lorenm committed
4126 4127

        //remaining coefficients have suffix_length > 0
4128
        for(i=trailing_ones+1;i<total_coeff;i++) {
lorenm's avatar
lorenm committed
4129 4130 4131 4132 4133
            static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
            prefix = get_level_prefix(gb);
            if(prefix<15){
                level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
            }else{
michael's avatar
michael committed
4134 4135 4136
                level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
                if(prefix>=16)
                    level_code += (1<<(prefix-3))-4096;
lorenm's avatar
lorenm committed
4137 4138 4139 4140 4141 4142
            }
            mask= -(level_code&1);
            level[i]= (((2+level_code)>>1) ^ mask) - mask;
            if(level_code > suffix_limit[suffix_length])
                suffix_length++;
        }
michaelni's avatar
michaelni committed
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153
    }

    if(total_coeff == max_coeff)
        zeros_left=0;
    else{
        if(n == CHROMA_DC_BLOCK_INDEX)
            zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
        else
            zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
    }

lorenm's avatar
lorenm committed
4154 4155
    coeff_num = zeros_left + total_coeff - 1;
    j = scantable[coeff_num];
michaelni's avatar
michaelni committed
4156
    if(n > 24){
lorenm's avatar
lorenm committed
4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167
        block[j] = level[0];
        for(i=1;i<total_coeff;i++) {
            if(zeros_left <= 0)
                run_before = 0;
            else if(zeros_left < 7){
                run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
            }else{
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
            }
            zeros_left -= run_before;
            coeff_num -= 1 + run_before;
michaelni's avatar
michaelni committed
4168 4169 4170 4171 4172
            j= scantable[ coeff_num ];

            block[j]= level[i];
        }
    }else{
lorenm's avatar
lorenm committed
4173
        block[j] = (level[0] * qmul[j] + 32)>>6;
lorenm's avatar
lorenm committed
4174 4175 4176 4177 4178 4179 4180 4181 4182 4183
        for(i=1;i<total_coeff;i++) {
            if(zeros_left <= 0)
                run_before = 0;
            else if(zeros_left < 7){
                run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
            }else{
                run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
            }
            zeros_left -= run_before;
            coeff_num -= 1 + run_before;
michaelni's avatar
michaelni committed
4184 4185
            j= scantable[ coeff_num ];

lorenm's avatar
lorenm committed
4186
            block[j]= (level[i] * qmul[j] + 32)>>6;
michaelni's avatar
michaelni committed
4187 4188
        }
    }
lorenm's avatar
lorenm committed
4189 4190 4191 4192 4193 4194

    if(zeros_left<0){
        av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
        return -1;
    }

michaelni's avatar
michaelni committed
4195 4196 4197
    return 0;
}

lorenm's avatar
lorenm committed
4198 4199
static void predict_field_decoding_flag(H264Context *h){
    MpegEncContext * const s = &h->s;
4200
    const int mb_xy= h->mb_xy;
lorenm's avatar
lorenm committed
4201 4202 4203 4204 4205 4206 4207 4208
    int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
                ? s->current_picture.mb_type[mb_xy-1]
                : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
                ? s->current_picture.mb_type[mb_xy-s->mb_stride]
                : 0;
    h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
}

4209 4210 4211 4212 4213
/**
 * decodes a P_SKIP or B_SKIP macroblock
 */
static void decode_mb_skip(H264Context *h){
    MpegEncContext * const s = &h->s;
4214
    const int mb_xy= h->mb_xy;
4215
    int mb_type=0;
4216

4217 4218 4219
    memset(h->non_zero_count[mb_xy], 0, 16);
    memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui

lorenm's avatar
lorenm committed
4220
    if(MB_FIELD)
4221
        mb_type|= MB_TYPE_INTERLACED;
4222

4223
    if( h->slice_type_nos == FF_B_TYPE )
4224 4225
    {
        // just for fill_caches. pred_direct_motion will set the real mb_type
4226
        mb_type|= MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
4227

michael's avatar
michael committed
4228
        fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
4229
        pred_direct_motion(h, &mb_type);
4230
        mb_type|= MB_TYPE_SKIP;
4231 4232 4233 4234
    }
    else
    {
        int mx, my;
4235
        mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
4236

michael's avatar
michael committed
4237
        fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
4238 4239 4240 4241 4242 4243
        pred_pskip_motion(h, &mx, &my);
        fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
        fill_rectangle(  h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
    }

    write_back_motion(h, mb_type);
4244
    s->current_picture.mb_type[mb_xy]= mb_type;
4245 4246
    s->current_picture.qscale_table[mb_xy]= s->qscale;
    h->slice_table[ mb_xy ]= h->slice_num;
4247
    h->prev_mb_skipped= 1;
4248 4249
}

michaelni's avatar
michaelni committed
4250 4251
/**
 * decodes a macroblock
diego's avatar
diego committed
4252
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
michaelni's avatar
michaelni committed
4253
 */
4254
static int decode_mb_cavlc(H264Context *h){
michaelni's avatar
michaelni committed
4255
    MpegEncContext * const s = &h->s;
4256
    int mb_xy;
4257 4258
    int partition_count;
    unsigned int mb_type, cbp;
lorenm's avatar
lorenm committed
4259
    int dct8x8_allowed= h->pps.transform_8x8_mode;
michaelni's avatar
michaelni committed
4260

4261 4262
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;

4263
    s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
michaelni's avatar
michaelni committed
4264

mbardiaux's avatar
mbardiaux committed
4265
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
bellard's avatar
bellard committed
4266 4267
    cbp = 0; /* avoid warning. FIXME: find a solution without slowing
                down the code */
michael's avatar
michael committed
4268
    if(h->slice_type_nos != FF_I_TYPE){
michaelni's avatar
michaelni committed
4269 4270
        if(s->mb_skip_run==-1)
            s->mb_skip_run= get_ue_golomb(&s->gb);
4271

michaelni's avatar
michaelni committed
4272
        if (s->mb_skip_run--) {
lorenm's avatar
lorenm committed
4273 4274 4275 4276 4277 4278
            if(FRAME_MBAFF && (s->mb_y&1) == 0){
                if(s->mb_skip_run==0)
                    h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
                else
                    predict_field_decoding_flag(h);
            }
4279
            decode_mb_skip(h);
michaelni's avatar
michaelni committed
4280 4281 4282
            return 0;
        }
    }
lorenm's avatar
lorenm committed
4283 4284 4285
    if(FRAME_MBAFF){
        if( (s->mb_y&1) == 0 )
            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
4286
    }
4287

4288
    h->prev_mb_skipped= 0;
4289

michaelni's avatar
michaelni committed
4290
    mb_type= get_ue_golomb(&s->gb);
4291
    if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
4292 4293 4294 4295 4296 4297 4298
        if(mb_type < 23){
            partition_count= b_mb_type_info[mb_type].partition_count;
            mb_type=         b_mb_type_info[mb_type].type;
        }else{
            mb_type -= 23;
            goto decode_intra_mb;
        }
4299
    }else if(h->slice_type_nos == FF_P_TYPE){
michaelni's avatar
michaelni committed
4300 4301 4302 4303 4304 4305 4306 4307
        if(mb_type < 5){
            partition_count= p_mb_type_info[mb_type].partition_count;
            mb_type=         p_mb_type_info[mb_type].type;
        }else{
            mb_type -= 5;
            goto decode_intra_mb;
        }
    }else{
4308 4309 4310
       assert(h->slice_type_nos == FF_I_TYPE);
        if(h->slice_type == FF_SI_TYPE && mb_type)
            mb_type--;
michaelni's avatar
michaelni committed
4311 4312
decode_intra_mb:
        if(mb_type > 25){
diego's avatar
diego committed
4313
            av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
4314 4315 4316 4317 4318 4319 4320 4321
            return -1;
        }
        partition_count=0;
        cbp= i_mb_type_info[mb_type].cbp;
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
        mb_type= i_mb_type_info[mb_type].type;
    }

lorenm's avatar
lorenm committed
4322
    if(MB_FIELD)
michaelni's avatar
michaelni committed
4323 4324 4325
        mb_type |= MB_TYPE_INTERLACED;

    h->slice_table[ mb_xy ]= h->slice_num;
4326

michaelni's avatar
michaelni committed
4327
    if(IS_INTRA_PCM(mb_type)){
michael's avatar
michael committed
4328
        unsigned int x;
4329

diego's avatar
diego committed
4330
        // We assume these blocks are very rare so we do not optimize it.
michaelni's avatar
michaelni committed
4331
        align_get_bits(&s->gb);
4332

4333
        // The pixels are stored in the same order as levels in h->mb array.
michael's avatar
michael committed
4334 4335
        for(x=0; x < (CHROMA ? 384 : 256); x++){
            ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
michaelni's avatar
michaelni committed
4336
        }
4337

4338
        // In deblocking, the quantizer is 0
4339
        s->current_picture.qscale_table[mb_xy]= 0;
4340
        // All coeffs are present
4341
        memset(h->non_zero_count[mb_xy], 16, 16);
4342

lorenm's avatar
lorenm committed
4343
        s->current_picture.mb_type[mb_xy]= mb_type;
michaelni's avatar
michaelni committed
4344 4345
        return 0;
    }
4346

lorenm's avatar
lorenm committed
4347 4348 4349 4350 4351
    if(MB_MBAFF){
        h->ref_count[0] <<= 1;
        h->ref_count[1] <<= 1;
    }

michael's avatar
michael committed
4352
    fill_caches(h, mb_type, 0);
michaelni's avatar
michaelni committed
4353 4354 4355

    //mb_pred
    if(IS_INTRA(mb_type)){
michael's avatar
michael committed
4356
        int pred_mode;
michaelni's avatar
michaelni committed
4357
//            init_top_left_availability(h);
michael's avatar
michael committed
4358 4359 4360 4361 4362 4363 4364
        if(IS_INTRA4x4(mb_type)){
            int i;
            int di = 1;
            if(dct8x8_allowed && get_bits1(&s->gb)){
                mb_type |= MB_TYPE_8x8DCT;
                di = 4;
            }
michaelni's avatar
michaelni committed
4365 4366

//                fill_intra4x4_pred_table(h);
michael's avatar
michael committed
4367 4368
            for(i=0; i<16; i+=di){
                int mode= pred_intra_mode(h, i);
michaelni's avatar
michaelni committed
4369

michael's avatar
michael committed
4370 4371 4372
                if(!get_bits1(&s->gb)){
                    const int rem_mode= get_bits(&s->gb, 3);
                    mode = rem_mode + (rem_mode >= mode);
michaelni's avatar
michaelni committed
4373
                }
michael's avatar
michael committed
4374 4375 4376 4377 4378

                if(di==4)
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
                else
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
michaelni's avatar
michaelni committed
4379
            }
michael's avatar
michael committed
4380 4381 4382 4383 4384 4385 4386 4387 4388
            write_back_intra_pred_mode(h);
            if( check_intra4x4_pred_mode(h) < 0)
                return -1;
        }else{
            h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
            if(h->intra16x16_pred_mode < 0)
                return -1;
        }
        if(CHROMA){
4389 4390
            pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb));
            if(pred_mode < 0)
michaelni's avatar
michaelni committed
4391
                return -1;
4392
            h->chroma_pred_mode= pred_mode;
michael's avatar
michael committed
4393
        }
michaelni's avatar
michaelni committed
4394 4395
    }else if(partition_count==4){
        int i, j, sub_partition_count[4], list, ref[2][4];
4396

4397
        if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
4398 4399 4400
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb(&s->gb);
                if(h->sub_mb_type[i] >=13){
4401
                    av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
4402 4403 4404 4405 4406
                    return -1;
                }
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
4407
            if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
4408
               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
4409
                pred_direct_motion(h, &mb_type);
4410 4411 4412 4413 4414
                h->ref_cache[0][scan8[4]] =
                h->ref_cache[1][scan8[4]] =
                h->ref_cache[0][scan8[12]] =
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
            }
michaelni's avatar
michaelni committed
4415
        }else{
michael's avatar
michael committed
4416
            assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
michaelni's avatar
michaelni committed
4417 4418 4419
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb(&s->gb);
                if(h->sub_mb_type[i] >=4){
4420
                    av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
4421 4422 4423 4424 4425 4426
                    return -1;
                }
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
        }
4427

4428
        for(list=0; list<h->list_count; list++){
4429
            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
michaelni's avatar
michaelni committed
4430
            for(i=0; i<4; i++){
4431 4432
                if(IS_DIRECT(h->sub_mb_type[i])) continue;
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
4433 4434 4435 4436 4437 4438
                    unsigned int tmp = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
                    if(tmp>=ref_count){
                        av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
                        return -1;
                    }
                    ref[list][i]= tmp;
michaelni's avatar
michaelni committed
4439 4440 4441 4442 4443 4444
                }else{
                 //FIXME
                    ref[list][i] = -1;
                }
            }
        }
4445

lorenm's avatar
lorenm committed
4446 4447
        if(dct8x8_allowed)
            dct8x8_allowed = get_dct8x8_allowed(h);
4448

4449
        for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4450
            for(i=0; i<4; i++){
4451 4452 4453 4454
                if(IS_DIRECT(h->sub_mb_type[i])) {
                    h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
                    continue;
                }
michaelni's avatar
michaelni committed
4455 4456 4457
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
                h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];

4458
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
michaelni's avatar
michaelni committed
4459 4460 4461 4462 4463 4464 4465 4466 4467
                    const int sub_mb_type= h->sub_mb_type[i];
                    const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
                    for(j=0; j<sub_partition_count[i]; j++){
                        int mx, my;
                        const int index= 4*i + block_width*j;
                        int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
                        pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
mbardiaux's avatar
mbardiaux committed
4468
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4469

michaelni's avatar
michaelni committed
4470
                        if(IS_SUB_8X8(sub_mb_type)){
4471
                            mv_cache[ 1 ][0]=
michaelni's avatar
michaelni committed
4472
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
4473
                            mv_cache[ 1 ][1]=
michaelni's avatar
michaelni committed
4474 4475
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
                        }else if(IS_SUB_8X4(sub_mb_type)){
4476 4477
                            mv_cache[ 1 ][0]= mx;
                            mv_cache[ 1 ][1]= my;
michaelni's avatar
michaelni committed
4478
                        }else if(IS_SUB_4X8(sub_mb_type)){
4479 4480
                            mv_cache[ 8 ][0]= mx;
                            mv_cache[ 8 ][1]= my;
michaelni's avatar
michaelni committed
4481
                        }
4482 4483
                        mv_cache[ 0 ][0]= mx;
                        mv_cache[ 0 ][1]= my;
michaelni's avatar
michaelni committed
4484 4485 4486 4487 4488 4489 4490 4491
                    }
                }else{
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
                    p[0] = p[1]=
                    p[8] = p[9]= 0;
                }
            }
        }
4492 4493
    }else if(IS_DIRECT(mb_type)){
        pred_direct_motion(h, &mb_type);
lorenm's avatar
lorenm committed
4494
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
4495
    }else{
michaelni's avatar
michaelni committed
4496 4497 4498
        int list, mx, my, i;
         //FIXME we should set ref_idx_l? to 0 if we use that later ...
        if(IS_16X16(mb_type)){
michael's avatar
michael committed
4499 4500
            for(list=0; list<h->list_count; list++){
                    unsigned int val;
michaelni's avatar
michaelni committed
4501
                    if(IS_DIR(mb_type, 0, list)){
michael's avatar
michael committed
4502
                        val= get_te0_golomb(&s->gb, h->ref_count[list]);
4503 4504 4505 4506
                        if(val >= h->ref_count[list]){
                            av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                            return -1;
                        }
lorenm's avatar
lorenm committed
4507
                    }else
michael's avatar
michael committed
4508 4509
                        val= LIST_NOT_USED&0xFF;
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
michaelni's avatar
michaelni committed
4510
            }
michael's avatar
michael committed
4511 4512
            for(list=0; list<h->list_count; list++){
                unsigned int val;
michaelni's avatar
michaelni committed
4513 4514 4515 4516
                if(IS_DIR(mb_type, 0, list)){
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
                    mx += get_se_golomb(&s->gb);
                    my += get_se_golomb(&s->gb);
mbardiaux's avatar
mbardiaux committed
4517
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4518

michael's avatar
michael committed
4519
                    val= pack16to32(mx,my);
lorenm's avatar
lorenm committed
4520
                }else
michael's avatar
michael committed
4521 4522
                    val=0;
                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
michaelni's avatar
michaelni committed
4523 4524 4525
            }
        }
        else if(IS_16X8(mb_type)){
michael's avatar
michael committed
4526
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4527
                    for(i=0; i<2; i++){
michael's avatar
michael committed
4528
                        unsigned int val;
michaelni's avatar
michaelni committed
4529
                        if(IS_DIR(mb_type, i, list)){
michael's avatar
michael committed
4530
                            val= get_te0_golomb(&s->gb, h->ref_count[list]);
4531 4532 4533 4534
                            if(val >= h->ref_count[list]){
                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                return -1;
                            }
lorenm's avatar
lorenm committed
4535
                        }else
michael's avatar
michael committed
4536 4537
                            val= LIST_NOT_USED&0xFF;
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
michaelni's avatar
michaelni committed
4538 4539
                    }
            }
michael's avatar
michael committed
4540
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4541
                for(i=0; i<2; i++){
michael's avatar
michael committed
4542
                    unsigned int val;
michaelni's avatar
michaelni committed
4543 4544 4545 4546
                    if(IS_DIR(mb_type, i, list)){
                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
mbardiaux's avatar
mbardiaux committed
4547
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4548

michael's avatar
michael committed
4549
                        val= pack16to32(mx,my);
4550
                    }else
michael's avatar
michael committed
4551 4552
                        val=0;
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
michaelni's avatar
michaelni committed
4553 4554 4555 4556
                }
            }
        }else{
            assert(IS_8X16(mb_type));
michael's avatar
michael committed
4557
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4558
                    for(i=0; i<2; i++){
michael's avatar
michael committed
4559
                        unsigned int val;
michaelni's avatar
michaelni committed
4560
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
michael's avatar
michael committed
4561
                            val= get_te0_golomb(&s->gb, h->ref_count[list]);
4562 4563 4564 4565
                            if(val >= h->ref_count[list]){
                                av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                return -1;
                            }
lorenm's avatar
lorenm committed
4566
                        }else
michael's avatar
michael committed
4567 4568
                            val= LIST_NOT_USED&0xFF;
                        fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
michaelni's avatar
michaelni committed
4569 4570
                    }
            }
michael's avatar
michael committed
4571
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4572
                for(i=0; i<2; i++){
michael's avatar
michael committed
4573
                    unsigned int val;
michaelni's avatar
michaelni committed
4574 4575 4576 4577
                    if(IS_DIR(mb_type, i, list)){
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
                        mx += get_se_golomb(&s->gb);
                        my += get_se_golomb(&s->gb);
mbardiaux's avatar
mbardiaux committed
4578
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4579

michael's avatar
michael committed
4580
                        val= pack16to32(mx,my);
4581
                    }else
michael's avatar
michael committed
4582 4583
                        val=0;
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
michaelni's avatar
michaelni committed
4584 4585 4586 4587
                }
            }
        }
    }
4588

michaelni's avatar
michaelni committed
4589 4590
    if(IS_INTER(mb_type))
        write_back_motion(h, mb_type);
4591

michaelni's avatar
michaelni committed
4592 4593 4594
    if(!IS_INTRA16x16(mb_type)){
        cbp= get_ue_golomb(&s->gb);
        if(cbp > 47){
4595
            av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
4596 4597
            return -1;
        }
4598

4599
        if(CHROMA){
michael's avatar
michael committed
4600 4601
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
            else                     cbp= golomb_to_inter_cbp   [cbp];
4602 4603 4604 4605
        }else{
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
            else                     cbp= golomb_to_inter_cbp_gray[cbp];
        }
michaelni's avatar
michaelni committed
4606
    }
lorenm's avatar
lorenm committed
4607
    h->cbp = cbp;
michaelni's avatar
michaelni committed
4608

lorenm's avatar
lorenm committed
4609
    if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
michael's avatar
michael committed
4610
        if(get_bits1(&s->gb)){
lorenm's avatar
lorenm committed
4611
            mb_type |= MB_TYPE_8x8DCT;
michael's avatar
michael committed
4612 4613
            h->cbp_table[mb_xy]= cbp;
        }
lorenm's avatar
lorenm committed
4614 4615 4616
    }
    s->current_picture.mb_type[mb_xy]= mb_type;

michaelni's avatar
michaelni committed
4617 4618
    if(cbp || IS_INTRA16x16(mb_type)){
        int i8x8, i4x4, chroma_idx;
4619
        int dquant;
michaelni's avatar
michaelni committed
4620
        GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
lorenm's avatar
lorenm committed
4621
        const uint8_t *scan, *scan8x8, *dc_scan;
4622

michaelni's avatar
michaelni committed
4623 4624 4625
//        fill_non_zero_count_cache(h);

        if(IS_INTERLACED(mb_type)){
lorenm's avatar
lorenm committed
4626
            scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
lorenm's avatar
lorenm committed
4627
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
michaelni's avatar
michaelni committed
4628 4629
            dc_scan= luma_dc_field_scan;
        }else{
lorenm's avatar
lorenm committed
4630
            scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
lorenm's avatar
lorenm committed
4631
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
michaelni's avatar
michaelni committed
4632 4633 4634 4635 4636 4637
            dc_scan= luma_dc_zigzag_scan;
        }

        dquant= get_se_golomb(&s->gb);

        if( dquant > 25 || dquant < -26 ){
4638
            av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
4639 4640
            return -1;
        }
4641

michaelni's avatar
michaelni committed
4642 4643 4644 4645 4646
        s->qscale += dquant;
        if(((unsigned)s->qscale) > 51){
            if(s->qscale<0) s->qscale+= 52;
            else            s->qscale-= 52;
        }
4647

4648 4649
        h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
        h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
michaelni's avatar
michaelni committed
4650
        if(IS_INTRA16x16(mb_type)){
lorenm's avatar
lorenm committed
4651
            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
4652
                return -1; //FIXME continue if partitioned and other return -1 too
michaelni's avatar
michaelni committed
4653 4654 4655 4656 4657 4658 4659 4660
            }

            assert((cbp&15) == 0 || (cbp&15) == 15);

            if(cbp&15){
                for(i8x8=0; i8x8<4; i8x8++){
                    for(i4x4=0; i4x4<4; i4x4++){
                        const int index= i4x4 + 4*i8x8;
lorenm's avatar
lorenm committed
4661
                        if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
michaelni's avatar
michaelni committed
4662 4663 4664 4665 4666
                            return -1;
                        }
                    }
                }
            }else{
michael's avatar
michael committed
4667
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
michaelni's avatar
michaelni committed
4668 4669 4670 4671
            }
        }else{
            for(i8x8=0; i8x8<4; i8x8++){
                if(cbp & (1<<i8x8)){
lorenm's avatar
lorenm committed
4672 4673
                    if(IS_8x8DCT(mb_type)){
                        DCTELEM *buf = &h->mb[64*i8x8];
mru's avatar
mru committed
4674
                        uint8_t *nnz;
lorenm's avatar
lorenm committed
4675
                        for(i4x4=0; i4x4<4; i4x4++){
lorenm's avatar
lorenm committed
4676
                            if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
lorenm's avatar
lorenm committed
4677
                                                h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
lorenm's avatar
lorenm committed
4678 4679
                                return -1;
                        }
mru's avatar
mru committed
4680
                        nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
4681
                        nnz[0] += nnz[1] + nnz[8] + nnz[9];
lorenm's avatar
lorenm committed
4682 4683 4684
                    }else{
                        for(i4x4=0; i4x4<4; i4x4++){
                            const int index= i4x4 + 4*i8x8;
4685

lorenm's avatar
lorenm committed
4686
                            if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
lorenm's avatar
lorenm committed
4687 4688
                                return -1;
                            }
michaelni's avatar
michaelni committed
4689 4690 4691 4692 4693 4694 4695 4696
                        }
                    }
                }else{
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
                }
            }
        }
4697

michaelni's avatar
michaelni committed
4698 4699
        if(cbp&0x30){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++)
lorenm's avatar
lorenm committed
4700
                if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
michaelni's avatar
michaelni committed
4701 4702 4703 4704 4705 4706
                    return -1;
                }
        }

        if(cbp&0x20){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++){
4707
                const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
michaelni's avatar
michaelni committed
4708 4709
                for(i4x4=0; i4x4<4; i4x4++){
                    const int index= 16 + 4*chroma_idx + i4x4;
4710
                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
michaelni's avatar
michaelni committed
4711 4712 4713 4714 4715 4716 4717 4718 4719 4720
                        return -1;
                    }
                }
            }
        }else{
            uint8_t * const nnz= &h->non_zero_count_cache[0];
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
        }
    }else{
4721 4722 4723 4724
        uint8_t * const nnz= &h->non_zero_count_cache[0];
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
michaelni's avatar
michaelni committed
4725
    }
4726
    s->current_picture.qscale_table[mb_xy]= s->qscale;
michaelni's avatar
michaelni committed
4727 4728
    write_back_non_zero_count(h);

lorenm's avatar
lorenm committed
4729 4730 4731 4732 4733
    if(MB_MBAFF){
        h->ref_count[0] >>= 1;
        h->ref_count[1] >>= 1;
    }

michaelni's avatar
michaelni committed
4734 4735 4736
    return 0;
}

4737 4738 4739 4740 4741 4742 4743 4744
static int decode_cabac_field_decoding_flag(H264Context *h) {
    MpegEncContext * const s = &h->s;
    const int mb_x = s->mb_x;
    const int mb_y = s->mb_y & ~1;
    const int mba_xy = mb_x - 1 +  mb_y   *s->mb_stride;
    const int mbb_xy = mb_x     + (mb_y-2)*s->mb_stride;

    unsigned int ctx = 0;
4745

4746 4747 4748 4749 4750 4751 4752
    if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
        ctx += 1;
    }
    if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
        ctx += 1;
    }

4753
    return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );
4754 4755
}

michael's avatar
michael committed
4756 4757 4758
static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
    uint8_t *state= &h->cabac_state[ctx_base];
    int mb_type;
4759

michael's avatar
michael committed
4760 4761
    if(intra_slice){
        MpegEncContext * const s = &h->s;
4762 4763
        const int mba_xy = h->left_mb_xy[0];
        const int mbb_xy = h->top_mb_xy;
michael's avatar
michael committed
4764
        int ctx=0;
4765
        if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
4766
            ctx++;
4767
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
4768
            ctx++;
4769
        if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
michael's avatar
michael committed
4770 4771 4772
            return 0;   /* I4x4 */
        state += 2;
    }else{
4773
        if( get_cabac_noinline( &h->cabac, &state[0] ) == 0 )
4774
            return 0;   /* I4x4 */
michael's avatar
michael committed
4775
    }
4776

michael's avatar
michael committed
4777 4778
    if( get_cabac_terminate( &h->cabac ) )
        return 25;  /* PCM */
4779

michael's avatar
michael committed
4780
    mb_type = 1; /* I16x16 */
4781 4782 4783 4784 4785
    mb_type += 12 * get_cabac_noinline( &h->cabac, &state[1] ); /* cbp_luma != 0 */
    if( get_cabac_noinline( &h->cabac, &state[2] ) ) /* cbp_chroma */
        mb_type += 4 + 4 * get_cabac_noinline( &h->cabac, &state[2+intra_slice] );
    mb_type += 2 * get_cabac_noinline( &h->cabac, &state[3+intra_slice] );
    mb_type += 1 * get_cabac_noinline( &h->cabac, &state[3+2*intra_slice] );
michael's avatar
michael committed
4786 4787
    return mb_type;
}
4788

michael's avatar
michael committed
4789 4790 4791
static int decode_cabac_mb_type( H264Context *h ) {
    MpegEncContext * const s = &h->s;

4792
    if( h->slice_type_nos == FF_I_TYPE ) {
michael's avatar
michael committed
4793
        return decode_cabac_intra_mb_type(h, 3, 1);
4794
    } else if( h->slice_type_nos == FF_P_TYPE ) {
4795
        if( get_cabac_noinline( &h->cabac, &h->cabac_state[14] ) == 0 ) {
4796
            /* P-type */
4797
            if( get_cabac_noinline( &h->cabac, &h->cabac_state[15] ) == 0 ) {
4798
                /* P_L0_D16x16, P_8x8 */
4799
                return 3 * get_cabac_noinline( &h->cabac, &h->cabac_state[16] );
4800
            } else {
4801
                /* P_L0_D8x16, P_L0_D16x8 */
4802
                return 2 - get_cabac_noinline( &h->cabac, &h->cabac_state[17] );
4803 4804
            }
        } else {
michael's avatar
michael committed
4805
            return decode_cabac_intra_mb_type(h, 17, 0) + 5;
4806
        }
4807
    } else {
4808 4809
        const int mba_xy = h->left_mb_xy[0];
        const int mbb_xy = h->top_mb_xy;
4810 4811
        int ctx = 0;
        int bits;
4812
        assert(h->slice_type_nos == FF_B_TYPE);
4813

4814
        if( h->slice_table[mba_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
4815
            ctx++;
4816
        if( h->slice_table[mbb_xy] == h->slice_num && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
4817 4818
            ctx++;

4819
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
4820 4821
            return 0; /* B_Direct_16x16 */

4822 4823
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+3] ) ) {
            return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
4824 4825
        }

4826 4827 4828 4829
        bits = get_cabac_noinline( &h->cabac, &h->cabac_state[27+4] ) << 3;
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 2;
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] ) << 1;
        bits|= get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
4830 4831 4832
        if( bits < 8 )
            return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
        else if( bits == 13 ) {
michael's avatar
michael committed
4833
            return decode_cabac_intra_mb_type(h, 32, 0) + 23;
4834 4835 4836 4837 4838
        } else if( bits == 14 )
            return 11; /* B_L1_L0_8x16 */
        else if( bits == 15 )
            return 22; /* B_8x8 */

4839
        bits= ( bits<<1 ) | get_cabac_noinline( &h->cabac, &h->cabac_state[27+5] );
4840
        return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
4841 4842 4843
    }
}

lorenm's avatar
lorenm committed
4844
static int decode_cabac_mb_skip( H264Context *h, int mb_x, int mb_y ) {
4845
    MpegEncContext * const s = &h->s;
lorenm's avatar
lorenm committed
4846
    int mba_xy, mbb_xy;
4847 4848
    int ctx = 0;

lorenm's avatar
lorenm committed
4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864
    if(FRAME_MBAFF){ //FIXME merge with the stuff in fill_caches?
        int mb_xy = mb_x + (mb_y&~1)*s->mb_stride;
        mba_xy = mb_xy - 1;
        if( (mb_y&1)
            && h->slice_table[mba_xy] == h->slice_num
            && MB_FIELD == !!IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) )
            mba_xy += s->mb_stride;
        if( MB_FIELD ){
            mbb_xy = mb_xy - s->mb_stride;
            if( !(mb_y&1)
                && h->slice_table[mbb_xy] == h->slice_num
                && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) )
                mbb_xy -= s->mb_stride;
        }else
            mbb_xy = mb_x + (mb_y-1)*s->mb_stride;
    }else{
4865
        int mb_xy = h->mb_xy;
lorenm's avatar
lorenm committed
4866
        mba_xy = mb_xy - 1;
4867
        mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
lorenm's avatar
lorenm committed
4868 4869
    }

4870
    if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
4871
        ctx++;
4872
    if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
4873 4874
        ctx++;

4875
    if( h->slice_type_nos == FF_B_TYPE )
4876
        ctx += 13;
4877
    return get_cabac_noinline( &h->cabac, &h->cabac_state[11+ctx] );
4878 4879 4880 4881 4882 4883 4884 4885
}

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

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

lorenm's avatar
lorenm committed
4886 4887 4888 4889
    mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
    mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
    mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );

4890 4891 4892 4893 4894 4895 4896
    if( mode >= pred_mode )
        return mode + 1;
    else
        return mode;
}

static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
4897 4898
    const int mba_xy = h->left_mb_xy[0];
    const int mbb_xy = h->top_mb_xy;
4899 4900 4901

    int ctx = 0;

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

4906
    if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
4907 4908
        ctx++;

4909
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
4910 4911
        return 0;

4912
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
4913
        return 1;
4914
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+3] ) == 0 )
4915 4916 4917 4918 4919 4920
        return 2;
    else
        return 3;
}

static int decode_cabac_mb_cbp_luma( H264Context *h) {
4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933
    int cbp_b, cbp_a, ctx, cbp = 0;

    cbp_a = h->slice_table[h->left_mb_xy[0]] == h->slice_num ? h->left_cbp : -1;
    cbp_b = h->slice_table[h->top_mb_xy]     == h->slice_num ? h->top_cbp  : -1;

    ctx = !(cbp_a & 0x02) + 2 * !(cbp_b & 0x04);
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]);
    ctx = !(cbp   & 0x01) + 2 * !(cbp_b & 0x08);
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 1;
    ctx = !(cbp_a & 0x08) + 2 * !(cbp   & 0x01);
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 2;
    ctx = !(cbp   & 0x04) + 2 * !(cbp   & 0x02);
    cbp |= get_cabac_noinline(&h->cabac, &h->cabac_state[73 + ctx]) << 3;
4934 4935 4936 4937 4938 4939
    return cbp;
}
static int decode_cabac_mb_cbp_chroma( H264Context *h) {
    int ctx;
    int cbp_a, cbp_b;

michael's avatar
michael committed
4940 4941
    cbp_a = (h->left_cbp>>4)&0x03;
    cbp_b = (h-> top_cbp>>4)&0x03;
4942 4943 4944 4945

    ctx = 0;
    if( cbp_a > 0 ) ctx++;
    if( cbp_b > 0 ) ctx += 2;
4946
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
4947 4948 4949 4950 4951
        return 0;

    ctx = 4;
    if( cbp_a == 2 ) ctx++;
    if( cbp_b == 2 ) ctx += 2;
4952
    return 1 + get_cabac_noinline( &h->cabac, &h->cabac_state[77 + ctx] );
4953 4954 4955 4956 4957
}
static int decode_cabac_mb_dqp( H264Context *h) {
    int   ctx = 0;
    int   val = 0;

lorenm's avatar
lorenm committed
4958
    if( h->last_qscale_diff != 0 )
4959 4960
        ctx++;

4961
    while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
4962 4963 4964 4965 4966
        if( ctx < 2 )
            ctx = 2;
        else
            ctx = 3;
        val++;
lorenm's avatar
lorenm committed
4967
        if(val > 102) //prevent infinite loop
4968
            return INT_MIN;
4969 4970 4971 4972 4973 4974 4975
    }

    if( val&0x01 )
        return (val + 1)/2;
    else
        return -(val + 1)/2;
}
4976
static int decode_cabac_p_mb_sub_type( H264Context *h ) {
4977 4978 4979 4980 4981 4982 4983 4984
    if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
        return 0;   /* 8x8 */
    if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
        return 1;   /* 8x4 */
    if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
        return 2;   /* 4x8 */
    return 3;       /* 4x4 */
}
4985 4986 4987 4988 4989
static int decode_cabac_b_mb_sub_type( H264Context *h ) {
    int type;
    if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
        return 0;   /* B_Direct_8x8 */
    if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
4990
        return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
4991 4992 4993 4994 4995 4996 4997 4998 4999 5000
    type = 3;
    if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
        if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
            return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
        type += 4;
    }
    type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
    type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
    return type;
}
5001

lorenm's avatar
lorenm committed
5002
static inline int decode_cabac_mb_transform_size( H264Context *h ) {
5003
    return get_cabac_noinline( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
lorenm's avatar
lorenm committed
5004 5005
}

5006 5007 5008 5009 5010 5011
static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
    int refa = h->ref_cache[list][scan8[n] - 1];
    int refb = h->ref_cache[list][scan8[n] - 8];
    int ref  = 0;
    int ctx  = 0;

5012
    if( h->slice_type_nos == FF_B_TYPE) {
5013 5014 5015 5016 5017 5018 5019 5020 5021 5022
        if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
            ctx++;
        if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
            ctx += 2;
    } else {
        if( refa > 0 )
            ctx++;
        if( refb > 0 )
            ctx += 2;
    }
5023 5024 5025 5026 5027 5028 5029

    while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
        ref++;
        if( ctx < 4 )
            ctx = 4;
        else
            ctx = 5;
5030 5031 5032 5033
        if(ref >= 32 /*h->ref_list[list]*/){
            av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_ref\n");
            return 0; //FIXME we should return -1 and check the return everywhere
        }
5034 5035 5036 5037 5038 5039 5040 5041
    }
    return ref;
}

static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
    int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
               abs( h->mvd_cache[list][scan8[n] - 8][l] );
    int ctxbase = (l == 0) ? 40 : 47;
michael's avatar
michael committed
5042
    int ctx, mvd;
5043 5044 5045 5046 5047 5048 5049 5050

    if( amvd < 3 )
        ctx = 0;
    else if( amvd > 32 )
        ctx = 2;
    else
        ctx = 1;

michael's avatar
michael committed
5051 5052 5053 5054 5055
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
        return 0;

    mvd= 1;
    ctx= 3;
5056 5057
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
        mvd++;
michael's avatar
michael committed
5058
        if( ctx < 6 )
5059 5060 5061 5062 5063 5064 5065 5066
            ctx++;
    }

    if( mvd >= 9 ) {
        int k = 3;
        while( get_cabac_bypass( &h->cabac ) ) {
            mvd += 1 << k;
            k++;
5067 5068 5069 5070
            if(k>24){
                av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
                return INT_MIN;
            }
5071 5072 5073 5074 5075 5076
        }
        while( k-- ) {
            if( get_cabac_bypass( &h->cabac ) )
                mvd += 1 << k;
        }
    }
5077
    return get_cabac_bypass_sign( &h->cabac, -mvd );
5078 5079
}

5080
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
michael's avatar
michael committed
5081
    int nza, nzb;
5082 5083
    int ctx = 0;

5084
    if( is_dc ) {
astrange's avatar
astrange committed
5085 5086 5087 5088 5089 5090 5091
        if( cat == 0 ) {
            nza = h->left_cbp&0x100;
            nzb = h-> top_cbp&0x100;
        } else {
            nza = (h->left_cbp>>(6+idx))&0x01;
            nzb = (h-> top_cbp>>(6+idx))&0x01;
        }
michael's avatar
michael committed
5092
    } else {
5093
        if( cat == 4 ) {
astrange's avatar
astrange committed
5094 5095
            nza = h->non_zero_count_cache[scan8[16+idx] - 1];
            nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
5096 5097 5098 5099
        } else {
            assert(cat == 1 || cat == 2);
            nza = h->non_zero_count_cache[scan8[idx] - 1];
            nzb = h->non_zero_count_cache[scan8[idx] - 8];
astrange's avatar
astrange committed
5100
        }
5101
    }
5102

michael's avatar
michael committed
5103
    if( nza > 0 )
5104 5105
        ctx++;

michael's avatar
michael committed
5106
    if( nzb > 0 )
5107 5108 5109 5110 5111
        ctx += 2;

    return ctx + 4 * cat;
}

5112
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8[63]) = {
michael's avatar
michael committed
5113 5114 5115 5116 5117 5118
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
    3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
    5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
};

5119
static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
lorenm's avatar
lorenm committed
5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130
    static const int significant_coeff_flag_offset[2][6] = {
      { 105+0, 105+15, 105+29, 105+44, 105+47, 402 },
      { 277+0, 277+15, 277+29, 277+44, 277+47, 436 }
    };
    static const int last_coeff_flag_offset[2][6] = {
      { 166+0, 166+15, 166+29, 166+44, 166+47, 417 },
      { 338+0, 338+15, 338+29, 338+44, 338+47, 451 }
    };
    static const int coeff_abs_level_m1_offset[6] = {
        227+0, 227+10, 227+20, 227+30, 227+39, 426
    };
michael's avatar
michael committed
5131
    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
lorenm's avatar
lorenm committed
5132
      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
lorenm's avatar
lorenm committed
5133 5134
        4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
        7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
lorenm's avatar
lorenm committed
5135 5136 5137 5138 5139
       12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12 },
      { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5,
        6, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,11,12,11,
        9, 9,10,10, 8,11,12,11, 9, 9,10,10, 8,13,13, 9,
        9,10,10, 8,13,13, 9, 9,10,10,14,14,14,14,14 }
lorenm's avatar
lorenm committed
5140
    };
5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152
    /* node ctx: 0..3: abslevel1 (with abslevelgt1 == 0).
     * 4..7: abslevelgt1 + 3 (and abslevel1 doesn't matter).
     * map node ctx => cabac ctx for level=1 */
    static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
    /* map node ctx => cabac ctx for level>1 */
    static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
    static const uint8_t coeff_abs_level_transition[2][8] = {
    /* update node ctx after decoding a level=1 */
        { 1, 2, 3, 3, 4, 5, 6, 7 },
    /* update node ctx after decoding a level>1 */
        { 4, 4, 4, 4, 5, 6, 7, 7 }
    };
lorenm's avatar
lorenm committed
5153 5154

    int index[64];
5155

benoit's avatar
benoit committed
5156
    int av_unused last;
5157
    int coeff_count = 0;
5158
    int node_ctx = 0;
5159

lorenm's avatar
lorenm committed
5160 5161 5162
    uint8_t *significant_coeff_ctx_base;
    uint8_t *last_coeff_ctx_base;
    uint8_t *abs_level_m1_ctx_base;
lorenm's avatar
lorenm committed
5163

5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177
#ifndef ARCH_X86
#define CABAC_ON_STACK
#endif
#ifdef CABAC_ON_STACK
#define CC &cc
    CABACContext cc;
    cc.range     = h->cabac.range;
    cc.low       = h->cabac.low;
    cc.bytestream= h->cabac.bytestream;
#else
#define CC &h->cabac
#endif


5178 5179 5180 5181 5182
    /* cat: 0-> DC 16x16  n = 0
     *      1-> AC 16x16  n = luma4x4idx
     *      2-> Luma4x4   n = luma4x4idx
     *      3-> DC Chroma n = iCbCr
     *      4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
lorenm's avatar
lorenm committed
5183
     *      5-> Luma8x8   n = 4 * luma8x8idx
5184 5185 5186
     */

    /* read coded block flag */
5187 5188 5189
    if( is_dc || cat != 5 ) {
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
            if( !is_dc ) {
5190
                if( cat == 4 )
astrange's avatar
astrange committed
5191
                    h->non_zero_count_cache[scan8[16+n]] = 0;
5192 5193
                else
                    h->non_zero_count_cache[scan8[n]] = 0;
5194 5195
            }

5196 5197 5198 5199 5200
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
5201
            return;
lorenm's avatar
lorenm committed
5202
        }
5203 5204
    }

lorenm's avatar
lorenm committed
5205
    significant_coeff_ctx_base = h->cabac_state
lorenm's avatar
lorenm committed
5206
        + significant_coeff_flag_offset[MB_FIELD][cat];
lorenm's avatar
lorenm committed
5207
    last_coeff_ctx_base = h->cabac_state
lorenm's avatar
lorenm committed
5208
        + last_coeff_flag_offset[MB_FIELD][cat];
lorenm's avatar
lorenm committed
5209 5210 5211
    abs_level_m1_ctx_base = h->cabac_state
        + coeff_abs_level_m1_offset[cat];

5212
    if( !is_dc && cat == 5 ) {
lorenm's avatar
lorenm committed
5213 5214 5215
#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
        for(last= 0; last < coefs; last++) { \
            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
5216
            if( get_cabac( CC, sig_ctx )) { \
lorenm's avatar
lorenm committed
5217 5218
                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
                index[coeff_count++] = last; \
5219
                if( get_cabac( CC, last_ctx ) ) { \
lorenm's avatar
lorenm committed
5220 5221 5222 5223
                    last= max_coeff; \
                    break; \
                } \
            } \
5224 5225 5226
        }\
        if( last == max_coeff -1 ) {\
            index[coeff_count++] = last;\
lorenm's avatar
lorenm committed
5227
        }
michael's avatar
michael committed
5228
        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
ramiro's avatar
ramiro committed
5229
#if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
michael's avatar
michael committed
5230 5231
        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
    } else {
5232
        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
5233
#else
michael's avatar
michael committed
5234 5235
        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
    } else {
lorenm's avatar
lorenm committed
5236
        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
5237
#endif
5238
    }
michael's avatar
michael committed
5239
    assert(coeff_count > 0);
5240

5241
    if( is_dc ) {
astrange's avatar
astrange committed
5242 5243 5244 5245
        if( cat == 0 )
            h->cbp_table[h->mb_xy] |= 0x100;
        else
            h->cbp_table[h->mb_xy] |= 0x40 << n;
5246
    } else {
5247 5248
        if( cat == 5 )
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
astrange's avatar
astrange committed
5249 5250 5251
        else if( cat == 4 )
            h->non_zero_count_cache[scan8[16+n]] = coeff_count;
        else {
5252 5253
            assert( cat == 1 || cat == 2 );
            h->non_zero_count_cache[scan8[n]] = coeff_count;
astrange's avatar
astrange committed
5254
        }
5255
    }
5256

5257
    do {
5258 5259
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;

5260
        int j= scantable[index[--coeff_count]];
5261

5262
        if( get_cabac( CC, ctx ) == 0 ) {
5263
            node_ctx = coeff_abs_level_transition[0][node_ctx];
5264
            if( is_dc ) {
5265
                block[j] = get_cabac_bypass_sign( CC, -1);
michael's avatar
michael committed
5266
            }else{
michael's avatar
michael committed
5267
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
michael's avatar
michael committed
5268
            }
5269
        } else {
michael's avatar
michael committed
5270
            int coeff_abs = 2;
5271 5272 5273
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
            node_ctx = coeff_abs_level_transition[1][node_ctx];

5274
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
michael's avatar
michael committed
5275
                coeff_abs++;
5276 5277
            }

michael's avatar
michael committed
5278 5279
            if( coeff_abs >= 15 ) {
                int j = 0;
5280
                while( get_cabac_bypass( CC ) ) {
michael's avatar
michael committed
5281 5282
                    j++;
                }
5283

michael's avatar
michael committed
5284
                coeff_abs=1;
michael's avatar
michael committed
5285
                while( j-- ) {
5286
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
michael's avatar
michael committed
5287
                }
michael's avatar
michael committed
5288
                coeff_abs+= 14;
5289 5290
            }

5291
            if( is_dc ) {
5292
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
michael's avatar
michael committed
5293
            }else{
5294
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
michael's avatar
michael committed
5295
            }
michael's avatar
michael committed
5296
        }
5297
    } while( coeff_count );
5298 5299 5300 5301 5302
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
5303

5304 5305
}

5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324
#ifndef CONFIG_SMALL
static void decode_cabac_residual_dc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 1);
}

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

static void decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
#ifdef CONFIG_SMALL
    decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, cat == 0 || cat == 3);
#else
    if( cat == 0 || cat == 3 ) decode_cabac_residual_dc(h, block, cat, n, scantable, qmul, max_coeff);
    else decode_cabac_residual_nondc(h, block, cat, n, scantable, qmul, max_coeff);
#endif
}

5325
static inline void compute_mb_neighbors(H264Context *h)
5326 5327
{
    MpegEncContext * const s = &h->s;
5328
    const int mb_xy  = h->mb_xy;
5329 5330
    h->top_mb_xy     = mb_xy - s->mb_stride;
    h->left_mb_xy[0] = mb_xy - 1;
lorenm's avatar
lorenm committed
5331
    if(FRAME_MBAFF){
5332 5333 5334 5335
        const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
        const int top_pair_xy      = pair_xy     - s->mb_stride;
        const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
        const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
lorenm's avatar
lorenm committed
5336
        const int curr_mb_frame_flag = !MB_FIELD;
5337 5338 5339 5340 5341 5342 5343 5344 5345 5346
        const int bottom = (s->mb_y & 1);
        if (bottom
                ? !curr_mb_frame_flag // bottom macroblock
                : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
                ) {
            h->top_mb_xy -= s->mb_stride;
        }
        if (left_mb_frame_flag != curr_mb_frame_flag) {
            h->left_mb_xy[0] = pair_xy - 1;
        }
5347 5348
    } else if (FIELD_PICTURE) {
        h->top_mb_xy -= s->mb_stride;
5349 5350 5351 5352
    }
    return;
}

5353 5354
/**
 * decodes a macroblock
diego's avatar
diego committed
5355
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
5356 5357 5358
 */
static int decode_mb_cabac(H264Context *h) {
    MpegEncContext * const s = &h->s;
5359
    int mb_xy;
5360
    int mb_type, partition_count, cbp = 0;
lorenm's avatar
lorenm committed
5361
    int dct8x8_allowed= h->pps.transform_8x8_mode;
5362

5363 5364
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;

5365
    s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
5366

mbardiaux's avatar
mbardiaux committed
5367
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
michael's avatar
michael committed
5368
    if( h->slice_type_nos != FF_I_TYPE ) {
lorenm's avatar
lorenm committed
5369 5370 5371 5372 5373 5374 5375 5376
        int skip;
        /* a skipped mb needs the aff flag from the following mb */
        if( FRAME_MBAFF && s->mb_x==0 && (s->mb_y&1)==0 )
            predict_field_decoding_flag(h);
        if( FRAME_MBAFF && (s->mb_y&1)==1 && h->prev_mb_skipped )
            skip = h->next_mb_skipped;
        else
            skip = decode_cabac_mb_skip( h, s->mb_x, s->mb_y );
5377
        /* read skip flags */
lorenm's avatar
lorenm committed
5378 5379 5380 5381 5382 5383 5384 5385 5386 5387
        if( skip ) {
            if( FRAME_MBAFF && (s->mb_y&1)==0 ){
                s->current_picture.mb_type[mb_xy] = MB_TYPE_SKIP;
                h->next_mb_skipped = decode_cabac_mb_skip( h, s->mb_x, s->mb_y+1 );
                if(h->next_mb_skipped)
                    predict_field_decoding_flag(h);
                else
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
            }

5388
            decode_mb_skip(h);
5389 5390

            h->cbp_table[mb_xy] = 0;
5391
            h->chroma_pred_mode_table[mb_xy] = 0;
5392 5393 5394 5395 5396 5397
            h->last_qscale_diff = 0;

            return 0;

        }
    }
lorenm's avatar
lorenm committed
5398 5399 5400
    if(FRAME_MBAFF){
        if( (s->mb_y&1) == 0 )
            h->mb_mbaff =
5401
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
5402
    }
5403

5404
    h->prev_mb_skipped = 0;
5405

diego's avatar
diego committed
5406
    compute_mb_neighbors(h);
5407 5408
    mb_type = decode_cabac_mb_type( h );
    assert(mb_type >= 0);
5409

5410
    if( h->slice_type_nos == FF_B_TYPE ) {
5411 5412 5413 5414 5415 5416 5417
        if( mb_type < 23 ){
            partition_count= b_mb_type_info[mb_type].partition_count;
            mb_type=         b_mb_type_info[mb_type].type;
        }else{
            mb_type -= 23;
            goto decode_intra_mb;
        }
5418
    } else if( h->slice_type_nos == FF_P_TYPE ) {
5419 5420 5421 5422 5423 5424 5425 5426
        if( mb_type < 5) {
            partition_count= p_mb_type_info[mb_type].partition_count;
            mb_type=         p_mb_type_info[mb_type].type;
        } else {
            mb_type -= 5;
            goto decode_intra_mb;
        }
    } else {
5427 5428 5429
        if(h->slice_type == FF_SI_TYPE && mb_type)
            mb_type--;
        assert(h->slice_type_nos == FF_I_TYPE);
5430 5431 5432 5433 5434 5435
decode_intra_mb:
        partition_count = 0;
        cbp= i_mb_type_info[mb_type].cbp;
        h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
        mb_type= i_mb_type_info[mb_type].type;
    }
lorenm's avatar
lorenm committed
5436
    if(MB_FIELD)
5437 5438 5439 5440 5441
        mb_type |= MB_TYPE_INTERLACED;

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

    if(IS_INTRA_PCM(mb_type)) {
5442
        const uint8_t *ptr;
5443

diego's avatar
diego committed
5444
        // We assume these blocks are very rare so we do not optimize it.
5445 5446 5447
        // FIXME The two following lines get the bitstream position in the cabac
        // decode, I think it should be done by a function in cabac.h (or cabac.c).
        ptr= h->cabac.bytestream;
5448 5449 5450 5451
        if(h->cabac.low&0x1) ptr--;
        if(CABAC_BITS==16){
            if(h->cabac.low&0x1FF) ptr--;
        }
5452 5453

        // The pixels are stored in the same order as levels in h->mb array.
michael's avatar
michael committed
5454
        memcpy(h->mb, ptr, 256); ptr+=256;
5455
        if(CHROMA){
michael's avatar
michael committed
5456
            memcpy(h->mb+128, ptr, 128); ptr+=128;
5457 5458 5459 5460
        }

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

5461
        // All blocks are present
5462
        h->cbp_table[mb_xy] = 0x1ef;
5463
        h->chroma_pred_mode_table[mb_xy] = 0;
5464
        // In deblocking, the quantizer is 0
5465
        s->current_picture.qscale_table[mb_xy]= 0;
5466
        // All coeffs are present
5467
        memset(h->non_zero_count[mb_xy], 16, 16);
lorenm's avatar
lorenm committed
5468
        s->current_picture.mb_type[mb_xy]= mb_type;
5469
        h->last_qscale_diff = 0;
5470
        return 0;
5471 5472
    }

lorenm's avatar
lorenm committed
5473 5474 5475 5476 5477
    if(MB_MBAFF){
        h->ref_count[0] <<= 1;
        h->ref_count[1] <<= 1;
    }

michael's avatar
michael committed
5478
    fill_caches(h, mb_type, 0);
5479 5480

    if( IS_INTRA( mb_type ) ) {
5481
        int i, pred_mode;
5482
        if( IS_INTRA4x4( mb_type ) ) {
lorenm's avatar
lorenm committed
5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493
            if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
                mb_type |= MB_TYPE_8x8DCT;
                for( i = 0; i < 16; i+=4 ) {
                    int pred = pred_intra_mode( h, i );
                    int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
                    fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
                }
            } else {
                for( i = 0; i < 16; i++ ) {
                    int pred = pred_intra_mode( h, i );
                    h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
5494 5495

                //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
lorenm's avatar
lorenm committed
5496
                }
5497 5498 5499 5500 5501 5502 5503
            }
            write_back_intra_pred_mode(h);
            if( check_intra4x4_pred_mode(h) < 0 ) return -1;
        } else {
            h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );
            if( h->intra16x16_pred_mode < 0 ) return -1;
        }
5504
        if(CHROMA){
michael's avatar
michael committed
5505 5506
            h->chroma_pred_mode_table[mb_xy] =
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
5507

michael's avatar
michael committed
5508 5509 5510
            pred_mode= check_intra_pred_mode( h, pred_mode );
            if( pred_mode < 0 ) return -1;
            h->chroma_pred_mode= pred_mode;
5511
        }
5512
    } else if( partition_count == 4 ) {
5513 5514
        int i, j, sub_partition_count[4], list, ref[2][4];

5515
        if( h->slice_type_nos == FF_B_TYPE ) {
5516 5517 5518 5519 5520
            for( i = 0; i < 4; i++ ) {
                h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
                sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
lorenm's avatar
lorenm committed
5521 5522
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
5523
                pred_direct_motion(h, &mb_type);
5524 5525 5526 5527
                h->ref_cache[0][scan8[4]] =
                h->ref_cache[1][scan8[4]] =
                h->ref_cache[0][scan8[12]] =
                h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
5528 5529 5530 5531 5532 5533
                if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
                    for( i = 0; i < 4; i++ )
                        if( IS_DIRECT(h->sub_mb_type[i]) )
                            fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
                }
            }
5534 5535 5536 5537 5538 5539
        } else {
            for( i = 0; i < 4; i++ ) {
                h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
                sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
                h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
            }
5540 5541
        }

5542
        for( list = 0; list < h->list_count; list++ ) {
5543
                for( i = 0; i < 4; i++ ) {
5544 5545
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
5546 5547 5548 5549 5550 5551 5552
                        if( h->ref_count[list] > 1 )
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
                        else
                            ref[list][i] = 0;
                    } else {
                        ref[list][i] = -1;
                    }
michael's avatar
1000l  
michael committed
5553
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
5554 5555 5556 5557
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
                }
        }

lorenm's avatar
lorenm committed
5558 5559 5560
        if(dct8x8_allowed)
            dct8x8_allowed = get_dct8x8_allowed(h);

5561
        for(list=0; list<h->list_count; list++){
5562
            for(i=0; i<4; i++){
5563
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
5564 5565 5566 5567
                if(IS_DIRECT(h->sub_mb_type[i])){
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
                    continue;
                }
5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581

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

                        mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
                        my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
mbardiaux's avatar
mbardiaux committed
5582
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5583 5584

                        if(IS_SUB_8X8(sub_mb_type)){
5585
                            mv_cache[ 1 ][0]=
5586
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
5587
                            mv_cache[ 1 ][1]=
5588 5589
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;

5590
                            mvd_cache[ 1 ][0]=
5591
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
5592
                            mvd_cache[ 1 ][1]=
5593 5594
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
                        }else if(IS_SUB_8X4(sub_mb_type)){
5595 5596
                            mv_cache[ 1 ][0]= mx;
                            mv_cache[ 1 ][1]= my;
5597

5598 5599
                            mvd_cache[ 1 ][0]= mx - mpx;
                            mvd_cache[ 1 ][1]= my - mpy;
5600
                        }else if(IS_SUB_4X8(sub_mb_type)){
5601 5602
                            mv_cache[ 8 ][0]= mx;
                            mv_cache[ 8 ][1]= my;
5603

5604 5605
                            mvd_cache[ 8 ][0]= mx - mpx;
                            mvd_cache[ 8 ][1]= my - mpy;
5606
                        }
5607 5608 5609 5610 5611
                        mv_cache[ 0 ][0]= mx;
                        mv_cache[ 0 ][1]= my;

                        mvd_cache[ 0 ][0]= mx - mpx;
                        mvd_cache[ 0 ][1]= my - mpy;
5612 5613 5614 5615 5616 5617 5618 5619 5620
                    }
                }else{
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
                    uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
                    p[0] = p[1] = p[8] = p[9] = 0;
                    pd[0]= pd[1]= pd[8]= pd[9]= 0;
                }
            }
        }
5621 5622 5623 5624
    } else if( IS_DIRECT(mb_type) ) {
        pred_direct_motion(h, &mb_type);
        fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
        fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
lorenm's avatar
lorenm committed
5625
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
5626
    } else {
5627 5628
        int list, mx, my, i, mpx, mpy;
        if(IS_16X16(mb_type)){
michael's avatar
michael committed
5629
            for(list=0; list<h->list_count; list++){
5630 5631 5632
                if(IS_DIR(mb_type, 0, list)){
                        const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
lorenm's avatar
lorenm committed
5633
                }else
michael's avatar
michael committed
5634
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1); //FIXME factorize and the other fill_rect below too
5635
            }
michael's avatar
michael committed
5636
            for(list=0; list<h->list_count; list++){
5637 5638 5639 5640 5641
                if(IS_DIR(mb_type, 0, list)){
                    pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);

                    mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
                    my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
mbardiaux's avatar
mbardiaux committed
5642
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5643 5644 5645

                    fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
lorenm's avatar
lorenm committed
5646 5647
                }else
                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
5648 5649 5650
            }
        }
        else if(IS_16X8(mb_type)){
5651
            for(list=0; list<h->list_count; list++){
5652 5653 5654 5655
                    for(i=0; i<2; i++){
                        if(IS_DIR(mb_type, i, list)){
                            const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
5656 5657
                        }else
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
5658 5659
                    }
            }
5660
            for(list=0; list<h->list_count; list++){
5661 5662 5663 5664 5665
                for(i=0; i<2; i++){
                    if(IS_DIR(mb_type, i, list)){
                        pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
                        mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
                        my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
mbardiaux's avatar
mbardiaux committed
5666
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5667 5668 5669

                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
lorenm's avatar
lorenm committed
5670
                    }else{
5671 5672
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
5673 5674 5675 5676 5677
                    }
                }
            }
        }else{
            assert(IS_8X16(mb_type));
5678
            for(list=0; list<h->list_count; list++){
5679 5680 5681 5682
                    for(i=0; i<2; i++){
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
                            const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
5683 5684
                        }else
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
5685 5686
                    }
            }
5687
            for(list=0; list<h->list_count; list++){
5688 5689 5690 5691 5692 5693
                for(i=0; i<2; i++){
                    if(IS_DIR(mb_type, i, list)){
                        pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
                        mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
                        my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );

mbardiaux's avatar
mbardiaux committed
5694
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5695 5696
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
                        fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
lorenm's avatar
lorenm committed
5697
                    }else{
5698 5699
                        fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
                        fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
5700 5701 5702 5703
                    }
                }
            }
        }
5704 5705
    }

5706 5707
   if( IS_INTER( mb_type ) ) {
        h->chroma_pred_mode_table[mb_xy] = 0;
5708
        write_back_motion( h, mb_type );
5709
   }
5710 5711 5712

    if( !IS_INTRA16x16( mb_type ) ) {
        cbp  = decode_cabac_mb_cbp_luma( h );
5713
        if(CHROMA)
michael's avatar
michael committed
5714
            cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
5715 5716
    }

lorenm's avatar
lorenm committed
5717
    h->cbp_table[mb_xy] = h->cbp = cbp;
5718

lorenm's avatar
lorenm committed
5719 5720 5721 5722 5723 5724
    if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
        if( decode_cabac_mb_transform_size( h ) )
            mb_type |= MB_TYPE_8x8DCT;
    }
    s->current_picture.mb_type[mb_xy]= mb_type;

5725
    if( cbp || IS_INTRA16x16( mb_type ) ) {
lorenm's avatar
lorenm committed
5726
        const uint8_t *scan, *scan8x8, *dc_scan;
5727
        const uint32_t *qmul;
5728 5729 5730
        int dqp;

        if(IS_INTERLACED(mb_type)){
lorenm's avatar
lorenm committed
5731
            scan8x8= s->qscale ? h->field_scan8x8 : h->field_scan8x8_q0;
lorenm's avatar
lorenm committed
5732
            scan= s->qscale ? h->field_scan : h->field_scan_q0;
5733 5734
            dc_scan= luma_dc_field_scan;
        }else{
lorenm's avatar
lorenm committed
5735
            scan8x8= s->qscale ? h->zigzag_scan8x8 : h->zigzag_scan8x8_q0;
lorenm's avatar
lorenm committed
5736
            scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
5737 5738 5739 5740
            dc_scan= luma_dc_zigzag_scan;
        }

        h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
5741 5742 5743 5744
        if( dqp == INT_MIN ){
            av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
            return -1;
        }
5745 5746 5747 5748 5749
        s->qscale += dqp;
        if(((unsigned)s->qscale) > 51){
            if(s->qscale<0) s->qscale+= 52;
            else            s->qscale-= 52;
        }
5750 5751
        h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
        h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
5752 5753 5754 5755

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

5758
            if( cbp&15 ) {
5759
                qmul = h->dequant4_coeff[0][s->qscale];
5760 5761
                for( i = 0; i < 16; i++ ) {
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
5762
                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
5763 5764 5765 5766 5767 5768 5769 5770
                }
            } else {
                fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
            }
        } else {
            int i8x8, i4x4;
            for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
                if( cbp & (1<<i8x8) ) {
lorenm's avatar
lorenm committed
5771
                    if( IS_8x8DCT(mb_type) ) {
5772 5773
                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
5774
                    } else {
andoma's avatar
andoma committed
5775 5776 5777 5778
                        qmul = h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale];
                        for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
                            const int index = 4*i8x8 + i4x4;
                            //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
5779
//START_TIMER
andoma's avatar
andoma committed
5780
                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
5781
//STOP_TIMER("decode_residual")
andoma's avatar
andoma committed
5782
                        }
5783
                    }
5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794
                } else {
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
                }
            }
        }

        if( cbp&0x30 ){
            int c;
            for( c = 0; c < 2; c++ ) {
                //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
5795
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
5796 5797 5798 5799 5800 5801
            }
        }

        if( cbp&0x20 ) {
            int c, i;
            for( c = 0; c < 2; c++ ) {
5802
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
5803 5804 5805
                for( i = 0; i < 4; i++ ) {
                    const int index = 16 + 4 * c + i;
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
5806
                    decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, qmul, 15);
5807 5808 5809 5810 5811 5812 5813 5814
                }
            }
        } else {
            uint8_t * const nnz= &h->non_zero_count_cache[0];
            nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
            nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
        }
    } else {
michael's avatar
michael committed
5815 5816 5817 5818
        uint8_t * const nnz= &h->non_zero_count_cache[0];
        fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
        nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
        nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
lorenm's avatar
lorenm committed
5819
        h->last_qscale_diff = 0;
5820 5821 5822 5823 5824
    }

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

lorenm's avatar
lorenm committed
5825 5826 5827 5828 5829
    if(MB_MBAFF){
        h->ref_count[0] >>= 1;
        h->ref_count[1] >>= 1;
    }

5830 5831 5832 5833
    return 0;
}


5834
static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
5835
    int i, d;
5836 5837 5838
    const int index_a = qp + h->slice_alpha_c0_offset;
    const int alpha = (alpha_table+52)[index_a];
    const int beta  = (beta_table+52)[qp + h->slice_beta_offset];
5839

lorenm's avatar
lorenm committed
5840
    if( bS[0] < 4 ) {
5841
        int8_t tc[4];
lorenm's avatar
lorenm committed
5842
        for(i=0; i<4; i++)
5843
            tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
lorenm's avatar
lorenm committed
5844 5845 5846 5847 5848
        h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
    } else {
        /* 16px edge length, because bS=4 is triggered by being at
         * the edge of an intra MB, so all 4 bS are the same */
            for( d = 0; d < 16; d++ ) {
michael's avatar
michael committed
5849 5850 5851 5852 5853 5854 5855 5856
                const int p0 = pix[-1];
                const int p1 = pix[-2];
                const int p2 = pix[-3];

                const int q0 = pix[0];
                const int q1 = pix[1];
                const int q2 = pix[2];

diego's avatar
diego committed
5857 5858 5859
                if( FFABS( p0 - q0 ) < alpha &&
                    FFABS( p1 - p0 ) < beta &&
                    FFABS( q1 - q0 ) < beta ) {
michael's avatar
michael committed
5860

diego's avatar
diego committed
5861 5862
                    if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
                        if( FFABS( p2 - p0 ) < beta)
michael's avatar
michael committed
5863 5864 5865 5866 5867 5868 5869 5870 5871 5872
                        {
                            const int p3 = pix[-4];
                            /* p0', p1', p2' */
                            pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
                            pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
                            pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
                        } else {
                            /* p0' */
                            pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                        }
diego's avatar
diego committed
5873
                        if( FFABS( q2 - q0 ) < beta)
michael's avatar
michael committed
5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888
                        {
                            const int q3 = pix[3];
                            /* q0', q1', q2' */
                            pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
                            pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
                            pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
                        } else {
                            /* q0' */
                            pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                        }
                    }else{
                        /* p0', q0' */
                        pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                        pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                    }
mbardiaux's avatar
mbardiaux committed
5889
                    tprintf(h->s.avctx, "filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]);
5890
                }
michael's avatar
michael committed
5891
                pix += stride;
5892 5893 5894
            }
    }
}
5895
static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
mru's avatar
mru committed
5896
    int i;
5897 5898 5899
    const int index_a = qp + h->slice_alpha_c0_offset;
    const int alpha = (alpha_table+52)[index_a];
    const int beta  = (beta_table+52)[qp + h->slice_beta_offset];
5900

lorenm's avatar
lorenm committed
5901
    if( bS[0] < 4 ) {
5902
        int8_t tc[4];
lorenm's avatar
lorenm committed
5903
        for(i=0; i<4; i++)
5904
            tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
lorenm's avatar
lorenm committed
5905 5906
        h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
    } else {
5907
        h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
5908 5909 5910
    }
}

5911
static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
5912 5913 5914 5915 5916
    int i;
    for( i = 0; i < 16; i++, pix += stride) {
        int index_a;
        int alpha;
        int beta;
5917

5918 5919
        int qp_index;
        int bS_index = (i >> 1);
lorenm's avatar
lorenm committed
5920
        if (!MB_FIELD) {
5921 5922 5923 5924 5925 5926 5927 5928
            bS_index &= ~1;
            bS_index |= (i & 1);
        }

        if( bS[bS_index] == 0 ) {
            continue;
        }

lorenm's avatar
lorenm committed
5929
        qp_index = MB_FIELD ? (i >> 3) : (i & 1);
5930 5931 5932
        index_a = qp[qp_index] + h->slice_alpha_c0_offset;
        alpha = (alpha_table+52)[index_a];
        beta  = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
5933 5934

        if( bS[bS_index] < 4 ) {
5935
            const int tc0 = (tc0_table+52)[index_a][bS[bS_index] - 1];
5936 5937 5938 5939 5940 5941 5942
            const int p0 = pix[-1];
            const int p1 = pix[-2];
            const int p2 = pix[-3];
            const int q0 = pix[0];
            const int q1 = pix[1];
            const int q2 = pix[2];

diego's avatar
diego committed
5943 5944 5945
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
5946 5947 5948
                int tc = tc0;
                int i_delta;

diego's avatar
diego committed
5949
                if( FFABS( p2 - p0 ) < beta ) {
reimar's avatar
reimar committed
5950
                    pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
5951 5952
                    tc++;
                }
diego's avatar
diego committed
5953
                if( FFABS( q2 - q0 ) < beta ) {
reimar's avatar
reimar committed
5954
                    pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
5955 5956 5957
                    tc++;
                }

reimar's avatar
reimar committed
5958 5959 5960
                i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
                pix[-1] = av_clip_uint8( p0 + i_delta );    /* p0' */
                pix[0]  = av_clip_uint8( q0 - i_delta );    /* q0' */
mbardiaux's avatar
mbardiaux committed
5961
                tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
5962 5963 5964 5965 5966 5967 5968 5969 5970 5971
            }
        }else{
            const int p0 = pix[-1];
            const int p1 = pix[-2];
            const int p2 = pix[-3];

            const int q0 = pix[0];
            const int q1 = pix[1];
            const int q2 = pix[2];

diego's avatar
diego committed
5972 5973 5974
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
5975

diego's avatar
diego committed
5976 5977
                if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
                    if( FFABS( p2 - p0 ) < beta)
5978 5979 5980 5981 5982 5983 5984 5985 5986 5987
                    {
                        const int p3 = pix[-4];
                        /* p0', p1', p2' */
                        pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
                        pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
                        pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
                    } else {
                        /* p0' */
                        pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                    }
diego's avatar
diego committed
5988
                    if( FFABS( q2 - q0 ) < beta)
5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003
                    {
                        const int q3 = pix[3];
                        /* q0', q1', q2' */
                        pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
                        pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
                        pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
                    } else {
                        /* q0' */
                        pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                    }
                }else{
                    /* p0', q0' */
                    pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                    pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                }
mbardiaux's avatar
mbardiaux committed
6004
                tprintf(h->s.avctx, "filter_mb_mbaff_edgev i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, p2, p1, p0, q0, q1, q2, pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
6005 6006 6007 6008
            }
        }
    }
}
6009
static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022
    int i;
    for( i = 0; i < 8; i++, pix += stride) {
        int index_a;
        int alpha;
        int beta;

        int qp_index;
        int bS_index = i;

        if( bS[bS_index] == 0 ) {
            continue;
        }

lorenm's avatar
lorenm committed
6023
        qp_index = MB_FIELD ? (i >> 2) : (i & 1);
6024 6025 6026
        index_a = qp[qp_index] + h->slice_alpha_c0_offset;
        alpha = (alpha_table+52)[index_a];
        beta  = (beta_table+52)[qp[qp_index] + h->slice_beta_offset];
lorenm's avatar
lorenm committed
6027

6028
        if( bS[bS_index] < 4 ) {
6029
            const int tc = (tc0_table+52)[index_a][bS[bS_index] - 1] + 1;
6030 6031 6032 6033 6034
            const int p0 = pix[-1];
            const int p1 = pix[-2];
            const int q0 = pix[0];
            const int q1 = pix[1];

diego's avatar
diego committed
6035 6036 6037
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
reimar's avatar
reimar committed
6038
                const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
6039

reimar's avatar
reimar committed
6040 6041
                pix[-1] = av_clip_uint8( p0 + i_delta );    /* p0' */
                pix[0]  = av_clip_uint8( q0 - i_delta );    /* q0' */
mbardiaux's avatar
mbardiaux committed
6042
                tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d, qp:%d, indexA:%d, alpha:%d, beta:%d, tc:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, qp[qp_index], index_a, alpha, beta, tc, bS[bS_index], pix[-3], p1, p0, q0, q1, pix[2], p1, pix[-1], pix[0], q1);
6043 6044 6045 6046 6047 6048 6049
            }
        }else{
            const int p0 = pix[-1];
            const int p1 = pix[-2];
            const int q0 = pix[0];
            const int q1 = pix[1];

diego's avatar
diego committed
6050 6051 6052
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
6053 6054 6055

                pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
                pix[0]  = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
mbardiaux's avatar
mbardiaux committed
6056
                tprintf(h->s.avctx, "filter_mb_mbaff_edgecv i:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x, %02x, %02x]\n", i, pix[-3], p1, p0, q0, q1, pix[2], pix[-3], pix[-2], pix[-1], pix[0], pix[1], pix[2]);
6057 6058 6059 6060 6061
            }
        }
    }
}

6062
static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6063
    int i, d;
6064 6065 6066
    const int index_a = qp + h->slice_alpha_c0_offset;
    const int alpha = (alpha_table+52)[index_a];
    const int beta  = (beta_table+52)[qp + h->slice_beta_offset];
6067 6068
    const int pix_next  = stride;

lorenm's avatar
lorenm committed
6069
    if( bS[0] < 4 ) {
6070
        int8_t tc[4];
lorenm's avatar
lorenm committed
6071
        for(i=0; i<4; i++)
6072
            tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] : -1;
lorenm's avatar
lorenm committed
6073 6074 6075 6076
        h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
    } else {
        /* 16px edge length, see filter_mb_edgev */
            for( d = 0; d < 16; d++ ) {
michael's avatar
michael committed
6077 6078 6079 6080 6081 6082 6083
                const int p0 = pix[-1*pix_next];
                const int p1 = pix[-2*pix_next];
                const int p2 = pix[-3*pix_next];
                const int q0 = pix[0];
                const int q1 = pix[1*pix_next];
                const int q2 = pix[2*pix_next];

diego's avatar
diego committed
6084 6085 6086
                if( FFABS( p0 - q0 ) < alpha &&
                    FFABS( p1 - p0 ) < beta &&
                    FFABS( q1 - q0 ) < beta ) {
michael's avatar
michael committed
6087 6088 6089 6090

                    const int p3 = pix[-4*pix_next];
                    const int q3 = pix[ 3*pix_next];

diego's avatar
diego committed
6091 6092
                    if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
                        if( FFABS( p2 - p0 ) < beta) {
michael's avatar
michael committed
6093 6094 6095 6096 6097 6098 6099 6100
                            /* p0', p1', p2' */
                            pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
                            pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
                            pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
                        } else {
                            /* p0' */
                            pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                        }
diego's avatar
diego committed
6101
                        if( FFABS( q2 - q0 ) < beta) {
michael's avatar
michael committed
6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114
                            /* q0', q1', q2' */
                            pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
                            pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
                            pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
                        } else {
                            /* q0' */
                            pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                        }
                    }else{
                        /* p0', q0' */
                        pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
                        pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
                    }
mbardiaux's avatar
mbardiaux committed
6115
                    tprintf(h->s.avctx, "filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]);
6116
                }
michael's avatar
michael committed
6117
                pix++;
6118 6119 6120 6121
            }
    }
}

6122
static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
mru's avatar
mru committed
6123
    int i;
6124 6125 6126
    const int index_a = qp + h->slice_alpha_c0_offset;
    const int alpha = (alpha_table+52)[index_a];
    const int beta  = (beta_table+52)[qp + h->slice_beta_offset];
6127

lorenm's avatar
lorenm committed
6128
    if( bS[0] < 4 ) {
6129
        int8_t tc[4];
lorenm's avatar
lorenm committed
6130
        for(i=0; i<4; i++)
6131
            tc[i] = bS[i] ? (tc0_table+52)[index_a][bS[i] - 1] + 1 : 0;
lorenm's avatar
lorenm committed
6132 6133
        h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
    } else {
6134
        h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
6135 6136 6137
    }
}

6138 6139
static void filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
    MpegEncContext * const s = &h->s;
6140
    int mb_y_firstrow = s->picture_structure == PICT_BOTTOM_FIELD;
6141 6142 6143
    int mb_xy, mb_type;
    int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;

6144
    mb_xy = h->mb_xy;
6145

6146
    if(mb_x==0 || mb_y==mb_y_firstrow || !s->dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff ||
6147
        !(s->flags2 & CODEC_FLAG2_FAST) || //FIXME filter_mb_fast is broken, thus hasto be, but should not under CODEC_FLAG2_FAST
6148 6149
       (h->deblocking_filter == 2 && (h->slice_table[mb_xy] != h->slice_table[h->top_mb_xy] ||
                                      h->slice_table[mb_xy] != h->slice_table[mb_xy - 1]))) {
6150 6151 6152 6153 6154 6155 6156 6157 6158
        filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
        return;
    }
    assert(!FRAME_MBAFF);

    mb_type = s->current_picture.mb_type[mb_xy];
    qp = s->current_picture.qscale_table[mb_xy];
    qp0 = s->current_picture.qscale_table[mb_xy-1];
    qp1 = s->current_picture.qscale_table[h->top_mb_xy];
6159 6160 6161
    qpc = get_chroma_qp( h, 0, qp );
    qpc0 = get_chroma_qp( h, 0, qp0 );
    qpc1 = get_chroma_qp( h, 0, qp1 );
6162 6163 6164 6165
    qp0 = (qp + qp0 + 1) >> 1;
    qp1 = (qp + qp1 + 1) >> 1;
    qpc0 = (qpc + qpc0 + 1) >> 1;
    qpc1 = (qpc + qpc1 + 1) >> 1;
lorenm's avatar
lorenm committed
6166 6167 6168 6169
    qp_thresh = 15 - h->slice_alpha_c0_offset;
    if(qp <= qp_thresh && qp0 <= qp_thresh && qp1 <= qp_thresh &&
       qpc <= qp_thresh && qpc0 <= qp_thresh && qpc1 <= qp_thresh)
        return;
6170 6171 6172 6173

    if( IS_INTRA(mb_type) ) {
        int16_t bS4[4] = {4,4,4,4};
        int16_t bS3[4] = {3,3,3,3};
andoma's avatar
andoma committed
6174
        int16_t *bSH = FIELD_PICTURE ? bS3 : bS4;
6175 6176 6177
        if( IS_8x8DCT(mb_type) ) {
            filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );
            filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );
andoma's avatar
andoma committed
6178
            filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bSH, qp1 );
6179 6180 6181 6182 6183 6184
            filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );
        } else {
            filter_mb_edgev( h, &img_y[4*0], linesize, bS4, qp0 );
            filter_mb_edgev( h, &img_y[4*1], linesize, bS3, qp );
            filter_mb_edgev( h, &img_y[4*2], linesize, bS3, qp );
            filter_mb_edgev( h, &img_y[4*3], linesize, bS3, qp );
andoma's avatar
andoma committed
6185
            filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bSH, qp1 );
6186 6187 6188 6189 6190 6191 6192 6193
            filter_mb_edgeh( h, &img_y[4*1*linesize], linesize, bS3, qp );
            filter_mb_edgeh( h, &img_y[4*2*linesize], linesize, bS3, qp );
            filter_mb_edgeh( h, &img_y[4*3*linesize], linesize, bS3, qp );
        }
        filter_mb_edgecv( h, &img_cb[2*0], uvlinesize, bS4, qpc0 );
        filter_mb_edgecv( h, &img_cb[2*2], uvlinesize, bS3, qpc );
        filter_mb_edgecv( h, &img_cr[2*0], uvlinesize, bS4, qpc0 );
        filter_mb_edgecv( h, &img_cr[2*2], uvlinesize, bS3, qpc );
andoma's avatar
andoma committed
6194
        filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1 );
6195
        filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc );
andoma's avatar
andoma committed
6196
        filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1 );
6197 6198 6199 6200 6201
        filter_mb_edgech( h, &img_cr[2*2*uvlinesize], uvlinesize, bS3, qpc );
        return;
    } else {
        DECLARE_ALIGNED_8(int16_t, bS[2][4][4]);
        uint64_t (*bSv)[4] = (uint64_t(*)[4])bS;
lorenm's avatar
lorenm committed
6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214
        int edges;
        if( IS_8x8DCT(mb_type) && (h->cbp&7) == 7 ) {
            edges = 4;
            bSv[0][0] = bSv[0][2] = bSv[1][0] = bSv[1][2] = 0x0002000200020002ULL;
        } else {
            int mask_edge1 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16)) ? 3 :
                             (mb_type & MB_TYPE_16x8) ? 1 : 0;
            int mask_edge0 = (mb_type & (MB_TYPE_16x16 | MB_TYPE_8x16))
                             && (s->current_picture.mb_type[mb_xy-1] & (MB_TYPE_16x16 | MB_TYPE_8x16))
                             ? 3 : 0;
            int step = IS_8x8DCT(mb_type) ? 2 : 1;
            edges = (mb_type & MB_TYPE_16x16) && !(h->cbp & 15) ? 1 : 4;
            s->dsp.h264_loop_filter_strength( bS, h->non_zero_count_cache, h->ref_cache, h->mv_cache,
6215
                                              (h->slice_type_nos == FF_B_TYPE), edges, step, mask_edge0, mask_edge1, FIELD_PICTURE);
lorenm's avatar
lorenm committed
6216
        }
6217
        if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) )
6218
            bSv[0][0] = 0x0004000400040004ULL;
6219
        if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) )
6220
            bSv[1][0] = FIELD_PICTURE ? 0x0003000300030003ULL : 0x0004000400040004ULL;
6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251

#define FILTER(hv,dir,edge)\
        if(bSv[dir][edge]) {\
            filter_mb_edge##hv( h, &img_y[4*edge*(dir?linesize:1)], linesize, bS[dir][edge], edge ? qp : qp##dir );\
            if(!(edge&1)) {\
                filter_mb_edgec##hv( h, &img_cb[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\
                filter_mb_edgec##hv( h, &img_cr[2*edge*(dir?uvlinesize:1)], uvlinesize, bS[dir][edge], edge ? qpc : qpc##dir );\
            }\
        }
        if( edges == 1 ) {
            FILTER(v,0,0);
            FILTER(h,1,0);
        } else if( IS_8x8DCT(mb_type) ) {
            FILTER(v,0,0);
            FILTER(v,0,2);
            FILTER(h,1,0);
            FILTER(h,1,2);
        } else {
            FILTER(v,0,0);
            FILTER(v,0,1);
            FILTER(v,0,2);
            FILTER(v,0,3);
            FILTER(h,1,0);
            FILTER(h,1,1);
            FILTER(h,1,2);
            FILTER(h,1,3);
        }
#undef FILTER
    }
}

6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 6386 6387 6388 6389 6390 6391 6392 6393

static void av_always_inline filter_mb_dir(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) {
    MpegEncContext * const s = &h->s;
    int edge;
    const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
    const int mbm_type = s->current_picture.mb_type[mbm_xy];
    int (*ref2frm) [64] = h->ref2frm[ h->slice_num          &(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
    int (*ref2frmm)[64] = h->ref2frm[ h->slice_table[mbm_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
    int start = h->slice_table[mbm_xy] == 0xFFFF ? 1 : 0;

    const int edges = (mb_type & (MB_TYPE_16x16|MB_TYPE_SKIP))
                              == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
    // how often to recheck mv-based bS when iterating between edges
    const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
                          (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
    // how often to recheck mv-based bS when iterating along each edge
    const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));

    if (first_vertical_edge_done) {
        start = 1;
    }

    if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
        start = 1;

    if (FRAME_MBAFF && (dir == 1) && ((mb_y&1) == 0) && start == 0
        && !IS_INTERLACED(mb_type)
        && IS_INTERLACED(mbm_type)
        ) {
        // This is a special case in the norm where the filtering must
        // be done twice (one each of the field) even if we are in a
        // frame macroblock.
        //
        static const int nnz_idx[4] = {4,5,6,3};
        unsigned int tmp_linesize   = 2 *   linesize;
        unsigned int tmp_uvlinesize = 2 * uvlinesize;
        int mbn_xy = mb_xy - 2 * s->mb_stride;
        int qp;
        int i, j;
        int16_t bS[4];

        for(j=0; j<2; j++, mbn_xy += s->mb_stride){
            if( IS_INTRA(mb_type) ||
                IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
                bS[0] = bS[1] = bS[2] = bS[3] = 3;
            } else {
                const uint8_t *mbn_nnz = h->non_zero_count[mbn_xy];
                for( i = 0; i < 4; i++ ) {
                    if( h->non_zero_count_cache[scan8[0]+i] != 0 ||
                        mbn_nnz[nnz_idx[i]] != 0 )
                        bS[i] = 2;
                    else
                        bS[i] = 1;
                }
            }
            // Do not use s->qscale as luma quantizer because it has not the same
            // value in IPCM macroblocks.
            qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
            tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, tmp_linesize, tmp_uvlinesize);
            { int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
            filter_mb_edgeh( h, &img_y[j*linesize], tmp_linesize, bS, qp );
            filter_mb_edgech( h, &img_cb[j*uvlinesize], tmp_uvlinesize, bS,
                              ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
            filter_mb_edgech( h, &img_cr[j*uvlinesize], tmp_uvlinesize, bS,
                              ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
        }

        start = 1;
    }

    /* Calculate bS */
    for( edge = start; edge < edges; edge++ ) {
        /* mbn_xy: neighbor macroblock */
        const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
        const int mbn_type = s->current_picture.mb_type[mbn_xy];
        int (*ref2frmn)[64] = edge > 0 ? ref2frm : ref2frmm;
        int16_t bS[4];
        int qp;

        if( (edge&1) && IS_8x8DCT(mb_type) )
            continue;

        if( IS_INTRA(mb_type) ||
            IS_INTRA(mbn_type) ) {
            int value;
            if (edge == 0) {
                if (   (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
                    || ((FRAME_MBAFF || (s->picture_structure != PICT_FRAME)) && (dir == 0))
                ) {
                    value = 4;
                } else {
                    value = 3;
                }
            } else {
                value = 3;
            }
            bS[0] = bS[1] = bS[2] = bS[3] = value;
        } else {
            int i, l;
            int mv_done;

            if( edge & mask_edge ) {
                bS[0] = bS[1] = bS[2] = bS[3] = 0;
                mv_done = 1;
            }
            else if( FRAME_MBAFF && IS_INTERLACED(mb_type ^ mbn_type)) {
                bS[0] = bS[1] = bS[2] = bS[3] = 1;
                mv_done = 1;
            }
            else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
                int b_idx= 8 + 4 + edge * (dir ? 8:1);
                int bn_idx= b_idx - (dir ? 8:1);
                int v = 0;

                for( l = 0; !v && l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
                    v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
                         FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
                         FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit;
                }

                if(h->slice_type_nos == FF_B_TYPE && v){
                    v=0;
                    for( l = 0; !v && l < 2; l++ ) {
                        int ln= 1-l;
                        v |= ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
                            FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
                            FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit;
                    }
                }

                bS[0] = bS[1] = bS[2] = bS[3] = v;
                mv_done = 1;
            }
            else
                mv_done = 0;

            for( i = 0; i < 4; i++ ) {
                int x = dir == 0 ? edge : i;
                int y = dir == 0 ? i    : edge;
                int b_idx= 8 + 4 + x + 8*y;
                int bn_idx= b_idx - (dir ? 8:1);

michael's avatar
michael committed
6394 6395
                if( h->non_zero_count_cache[b_idx] |
                    h->non_zero_count_cache[bn_idx] ) {
6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455
                    bS[i] = 2;
                }
                else if(!mv_done)
                {
                    bS[i] = 0;
                    for( l = 0; l < 1 + (h->slice_type_nos == FF_B_TYPE); l++ ) {
                        if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[l][h->ref_cache[l][bn_idx]] ||
                            FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
                            FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= mvy_limit ) {
                            bS[i] = 1;
                            break;
                        }
                    }

                    if(h->slice_type_nos == FF_B_TYPE && bS[i]){
                        bS[i] = 0;
                        for( l = 0; l < 2; l++ ) {
                            int ln= 1-l;
                            if( ref2frm[l][h->ref_cache[l][b_idx]] != ref2frmn[ln][h->ref_cache[ln][bn_idx]] ||
                                FFABS( h->mv_cache[l][b_idx][0] - h->mv_cache[ln][bn_idx][0] ) >= 4 ||
                                FFABS( h->mv_cache[l][b_idx][1] - h->mv_cache[ln][bn_idx][1] ) >= mvy_limit ) {
                                bS[i] = 1;
                                break;
                            }
                        }
                    }
                }
            }

            if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
                continue;
        }

        /* Filter edge */
        // Do not use s->qscale as luma quantizer because it has not the same
        // value in IPCM macroblocks.
        qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
        //tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp, s->current_picture.qscale_table[mbn_xy]);
        tprintf(s->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
        { int i; for (i = 0; i < 4; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
        if( dir == 0 ) {
            filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
            if( (edge&1) == 0 ) {
                filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS,
                                  ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
                filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS,
                                  ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
            }
        } else {
            filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
            if( (edge&1) == 0 ) {
                filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS,
                                  ( h->chroma_qp[0] + get_chroma_qp( h, 0, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
                filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS,
                                  ( h->chroma_qp[1] + get_chroma_qp( h, 1, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1);
            }
        }
    }
}

6456
static void filter_mb( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
6457 6458
    MpegEncContext * const s = &h->s;
    const int mb_xy= mb_x + mb_y*s->mb_stride;
lorenm's avatar
lorenm committed
6459 6460
    const int mb_type = s->current_picture.mb_type[mb_xy];
    const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
6461
    int first_vertical_edge_done = 0;
6462 6463
    int dir;

lorenm's avatar
lorenm committed
6464 6465
    //for sufficiently low qp, filtering wouldn't do anything
    //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
lorenm's avatar
lorenm committed
6466
    if(!FRAME_MBAFF){
6467
        int qp_thresh = 15 - h->slice_alpha_c0_offset - FFMAX3(0, h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1]);
lorenm's avatar
lorenm committed
6468 6469 6470 6471 6472 6473 6474 6475
        int qp = s->current_picture.qscale_table[mb_xy];
        if(qp <= qp_thresh
           && (mb_x == 0 || ((qp + s->current_picture.qscale_table[mb_xy-1] + 1)>>1) <= qp_thresh)
           && (mb_y == 0 || ((qp + s->current_picture.qscale_table[h->top_mb_xy] + 1)>>1) <= qp_thresh)){
            return;
        }
    }

michael's avatar
michael committed
6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499
    // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
    if(!h->pps.cabac && h->pps.transform_8x8_mode){
        int top_type, left_type[2];
        top_type     = s->current_picture.mb_type[h->top_mb_xy]    ;
        left_type[0] = s->current_picture.mb_type[h->left_mb_xy[0]];
        left_type[1] = s->current_picture.mb_type[h->left_mb_xy[1]];

        if(IS_8x8DCT(top_type)){
            h->non_zero_count_cache[4+8*0]=
            h->non_zero_count_cache[5+8*0]= h->cbp_table[h->top_mb_xy] & 4;
            h->non_zero_count_cache[6+8*0]=
            h->non_zero_count_cache[7+8*0]= h->cbp_table[h->top_mb_xy] & 8;
        }
        if(IS_8x8DCT(left_type[0])){
            h->non_zero_count_cache[3+8*1]=
            h->non_zero_count_cache[3+8*2]= h->cbp_table[h->left_mb_xy[0]]&2; //FIXME check MBAFF
        }
        if(IS_8x8DCT(left_type[1])){
            h->non_zero_count_cache[3+8*3]=
            h->non_zero_count_cache[3+8*4]= h->cbp_table[h->left_mb_xy[1]]&8; //FIXME check MBAFF
        }

        if(IS_8x8DCT(mb_type)){
            h->non_zero_count_cache[scan8[0   ]]= h->non_zero_count_cache[scan8[1   ]]=
michael's avatar
michael committed
6500
            h->non_zero_count_cache[scan8[2   ]]= h->non_zero_count_cache[scan8[3   ]]= h->cbp & 1;
michael's avatar
michael committed
6501 6502

            h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
michael's avatar
michael committed
6503
            h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
michael's avatar
michael committed
6504 6505

            h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
michael's avatar
michael committed
6506
            h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
michael's avatar
michael committed
6507 6508

            h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
michael's avatar
michael committed
6509
            h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
michael's avatar
michael committed
6510 6511 6512
        }
    }

lorenm's avatar
lorenm committed
6513
    if (FRAME_MBAFF
6514
            // left mb is in picture
6515
            && h->slice_table[mb_xy-1] != 0xFFFF
6516
            // and current and left pair do not have the same interlaced type
lorenm's avatar
lorenm committed
6517
            && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
6518 6519 6520
            // and left mb is in the same slice if deblocking_filter == 2
            && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {
        /* First vertical edge is different in MBAFF frames
6521
         * There are 8 different bS to compute and 2 different Qp
6522
         */
lorenm's avatar
lorenm committed
6523 6524
        const int pair_xy = mb_x + (mb_y&~1)*s->mb_stride;
        const int left_mb_xy[2] = { pair_xy-1, pair_xy-1+s->mb_stride };
6525
        int16_t bS[8];
6526
        int qp[2];
6527 6528
        int bqp[2];
        int rqp[2];
lorenm's avatar
lorenm committed
6529
        int mb_qp, mbn0_qp, mbn1_qp;
6530 6531
        int i;
        first_vertical_edge_done = 1;
lorenm's avatar
lorenm committed
6532 6533 6534 6535 6536 6537 6538 6539 6540 6541

        if( IS_INTRA(mb_type) )
            bS[0] = bS[1] = bS[2] = bS[3] = bS[4] = bS[5] = bS[6] = bS[7] = 4;
        else {
            for( i = 0; i < 8; i++ ) {
                int mbn_xy = MB_FIELD ? left_mb_xy[i>>2] : left_mb_xy[i&1];

                if( IS_INTRA( s->current_picture.mb_type[mbn_xy] ) )
                    bS[i] = 4;
                else if( h->non_zero_count_cache[12+8*(i>>1)] != 0 ||
michael's avatar
michael committed
6542 6543 6544 6545
                         ((!h->pps.cabac && IS_8x8DCT(s->current_picture.mb_type[mbn_xy])) ?
                            (h->cbp_table[mbn_xy] & ((MB_FIELD ? (i&2) : (mb_y&1)) ? 8 : 2))
                                                                       :
                            h->non_zero_count[mbn_xy][MB_FIELD ? i&3 : (i>>2)+(mb_y&1)*2]))
lorenm's avatar
lorenm committed
6546 6547 6548
                    bS[i] = 2;
                else
                    bS[i] = 1;
6549 6550 6551
            }
        }

lorenm's avatar
lorenm committed
6552 6553 6554 6555
        mb_qp = s->current_picture.qscale_table[mb_xy];
        mbn0_qp = s->current_picture.qscale_table[left_mb_xy[0]];
        mbn1_qp = s->current_picture.qscale_table[left_mb_xy[1]];
        qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
6556 6557 6558 6559
        bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) +
                   get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1;
        rqp[0] = ( get_chroma_qp( h, 1, mb_qp ) +
                   get_chroma_qp( h, 1, mbn0_qp ) + 1 ) >> 1;
lorenm's avatar
lorenm committed
6560
        qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
6561 6562 6563 6564
        bqp[1] = ( get_chroma_qp( h, 0, mb_qp ) +
                   get_chroma_qp( h, 0, mbn1_qp ) + 1 ) >> 1;
        rqp[1] = ( get_chroma_qp( h, 1, mb_qp ) +
                   get_chroma_qp( h, 1, mbn1_qp ) + 1 ) >> 1;
lorenm's avatar
lorenm committed
6565 6566

        /* Filter edge */
6567
        tprintf(s->avctx, "filter mb:%d/%d MBAFF, QPy:%d/%d, QPb:%d/%d QPr:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], bqp[0], bqp[1], rqp[0], rqp[1], linesize, uvlinesize);
mbardiaux's avatar
mbardiaux committed
6568
        { int i; for (i = 0; i < 8; i++) tprintf(s->avctx, " bS[%d]:%d", i, bS[i]); tprintf(s->avctx, "\n"); }
lorenm's avatar
lorenm committed
6569
        filter_mb_mbaff_edgev ( h, &img_y [0], linesize,   bS, qp );
6570 6571
        filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, bqp );
        filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, rqp );
6572
    }
6573

6574 6575 6576 6577 6578 6579 6580
#ifdef CONFIG_SMALL
    for( dir = 0; dir < 2; dir++ )
        filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, dir ? 0 : first_vertical_edge_done, dir);
#else
    filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, first_vertical_edge_done, 0);
    filter_mb_dir(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, mb_xy, mb_type, mvy_limit, 0, 1);
#endif
6581 6582
}

6583 6584
static int decode_slice(struct AVCodecContext *avctx, void *arg){
    H264Context *h = *(void**)arg;
michaelni's avatar
michaelni committed
6585 6586 6587 6588 6589
    MpegEncContext * const s = &h->s;
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;

    s->mb_skip_run= -1;

6590
    h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
6591
                    (ENABLE_GRAY && (s->flags&CODEC_FLAG_GRAY)) || (ENABLE_H264_ENCODER && s->encoding);
6592

6593 6594
    if( h->pps.cabac ) {
        int i;
michaelni's avatar
michaelni committed
6595

6596 6597 6598 6599
        /* realign */
        align_get_bits( &s->gb );

        /* init cabac */
6600
        ff_init_cabac_states( &h->cabac);
6601 6602
        ff_init_cabac_decoder( &h->cabac,
                               s->gb.buffer + get_bits_count(&s->gb)/8,
michael's avatar
michael committed
6603
                               ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
6604
        /* calculate pre-state */
lorenm's avatar
lorenm committed
6605
        for( i= 0; i < 460; i++ ) {
6606
            int pre;
6607
            if( h->slice_type_nos == FF_I_TYPE )
reimar's avatar
reimar committed
6608
                pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
6609
            else
reimar's avatar
reimar committed
6610
                pre = av_clip( ((cabac_context_init_PB[h->cabac_init_idc][i][0] * s->qscale) >>4 ) + cabac_context_init_PB[h->cabac_init_idc][i][1], 1, 126 );
6611 6612

            if( pre <= 63 )
6613
                h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
6614
            else
6615
                h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
michaelni's avatar
michaelni committed
6616
        }
6617

6618
        for(;;){
6619
//START_TIMER
6620
            int ret = decode_mb_cabac(h);
6621
            int eos;
6622
//STOP_TIMER("decode_mb_cabac")
michaelni's avatar
michaelni committed
6623

michael's avatar
michael committed
6624
            if(ret>=0) hl_decode_mb(h);
michaelni's avatar
michaelni committed
6625

lorenm's avatar
lorenm committed
6626
            if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
6627 6628
                s->mb_y++;

michael's avatar
michael committed
6629
                if(ret>=0) ret = decode_mb_cabac(h);
6630

6631
                if(ret>=0) hl_decode_mb(h);
6632 6633
                s->mb_y--;
            }
6634
            eos = get_cabac_terminate( &h->cabac );
6635

6636
            if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
mru's avatar
mru committed
6637
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream);
6638 6639 6640 6641 6642 6643 6644
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);
                return -1;
            }

            if( ++s->mb_x >= s->mb_width ) {
                s->mb_x = 0;
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
michael's avatar
michael committed
6645
                ++s->mb_y;
6646
                if(FIELD_OR_MBAFF_PICTURE) {
6647 6648
                    ++s->mb_y;
                }
michaelni's avatar
michaelni committed
6649 6650
            }

6651
            if( eos || s->mb_y >= s->mb_height ) {
mbardiaux's avatar
mbardiaux committed
6652
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6653
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
michaelni's avatar
michaelni committed
6654
                return 0;
6655 6656 6657 6658 6659 6660 6661
            }
        }

    } else {
        for(;;){
            int ret = decode_mb_cavlc(h);

michael's avatar
michael committed
6662
            if(ret>=0) hl_decode_mb(h);
6663

lorenm's avatar
lorenm committed
6664
            if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
6665 6666 6667
                s->mb_y++;
                ret = decode_mb_cavlc(h);

michael's avatar
michael committed
6668
                if(ret>=0) hl_decode_mb(h);
6669 6670 6671 6672 6673
                s->mb_y--;
            }

            if(ret<0){
                av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
6674 6675 6676 6677
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

                return -1;
            }
6678 6679 6680 6681

            if(++s->mb_x >= s->mb_width){
                s->mb_x=0;
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
6682
                ++s->mb_y;
6683
                if(FIELD_OR_MBAFF_PICTURE) {
6684 6685 6686
                    ++s->mb_y;
                }
                if(s->mb_y >= s->mb_height){
mbardiaux's avatar
mbardiaux committed
6687
                    tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701

                    if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                        return 0;
                    }else{
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                        return -1;
                    }
                }
            }

            if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
mbardiaux's avatar
mbardiaux committed
6702
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6703 6704 6705 6706 6707 6708 6709 6710 6711 6712
                if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
                    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                    return 0;
                }else{
                    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

                    return -1;
                }
            }
michaelni's avatar
michaelni committed
6713 6714
        }
    }
6715

michaelni's avatar
michaelni committed
6716 6717 6718 6719
#if 0
    for(;s->mb_y < s->mb_height; s->mb_y++){
        for(;s->mb_x < s->mb_width; s->mb_x++){
            int ret= decode_mb(h);
6720

michaelni's avatar
michaelni committed
6721 6722 6723
            hl_decode_mb(h);

            if(ret<0){
diego's avatar
diego committed
6724
                av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
michaelni's avatar
michaelni committed
6725 6726 6727 6728
                ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

                return -1;
            }
6729

michaelni's avatar
michaelni committed
6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741 6742 6743
            if(++s->mb_x >= s->mb_width){
                s->mb_x=0;
                if(++s->mb_y >= s->mb_height){
                    if(get_bits_count(s->gb) == s->gb.size_in_bits){
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                        return 0;
                    }else{
                        ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                        return -1;
                    }
                }
            }
6744

michaelni's avatar
michaelni committed
6745 6746 6747 6748 6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763
            if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
                if(get_bits_count(s->gb) == s->gb.size_in_bits){
                    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);

                    return 0;
                }else{
                    ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask);

                    return -1;
                }
            }
        }
        s->mb_x=0;
        ff_draw_horiz_band(s, 16*s->mb_y, 16);
    }
#endif
    return -1; //not reached
}

6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793 6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805 6806 6807 6808 6809 6810
static int decode_picture_timing(H264Context *h){
    MpegEncContext * const s = &h->s;
    if(h->sps.nal_hrd_parameters_present_flag || h->sps.vcl_hrd_parameters_present_flag){
        skip_bits(&s->gb, h->sps.cpb_removal_delay_length); /* cpb_removal_delay */
        skip_bits(&s->gb, h->sps.dpb_output_delay_length);  /* dpb_output_delay */
    }
    if(h->sps.pic_struct_present_flag){
        unsigned int i, num_clock_ts;
        h->sei_pic_struct = get_bits(&s->gb, 4);

        if (h->sei_pic_struct > SEI_PIC_STRUCT_FRAME_TRIPLING)
            return -1;

        num_clock_ts = sei_num_clock_ts_table[h->sei_pic_struct];

        for (i = 0 ; i < num_clock_ts ; i++){
            if(get_bits(&s->gb, 1)){                  /* clock_timestamp_flag */
                unsigned int full_timestamp_flag;
                skip_bits(&s->gb, 2);                 /* ct_type */
                skip_bits(&s->gb, 1);                 /* nuit_field_based_flag */
                skip_bits(&s->gb, 5);                 /* counting_type */
                full_timestamp_flag = get_bits(&s->gb, 1);
                skip_bits(&s->gb, 1);                 /* discontinuity_flag */
                skip_bits(&s->gb, 1);                 /* cnt_dropped_flag */
                skip_bits(&s->gb, 8);                 /* n_frames */
                if(full_timestamp_flag){
                    skip_bits(&s->gb, 6);             /* seconds_value 0..59 */
                    skip_bits(&s->gb, 6);             /* minutes_value 0..59 */
                    skip_bits(&s->gb, 5);             /* hours_value 0..23 */
                }else{
                    if(get_bits(&s->gb, 1)){          /* seconds_flag */
                        skip_bits(&s->gb, 6);         /* seconds_value range 0..59 */
                        if(get_bits(&s->gb, 1)){      /* minutes_flag */
                            skip_bits(&s->gb, 6);     /* minutes_value 0..59 */
                            if(get_bits(&s->gb, 1))   /* hours_flag */
                                skip_bits(&s->gb, 5); /* hours_value 0..23 */
                        }
                    }
                }
                if(h->sps.time_offset_length > 0)
                    skip_bits(&s->gb, h->sps.time_offset_length); /* time_offset */
            }
        }
    }
    return 0;
}

6811 6812 6813 6814
static int decode_unregistered_user_data(H264Context *h, int size){
    MpegEncContext * const s = &h->s;
    uint8_t user_data[16+256];
    int e, build, i;
6815

6816 6817
    if(size<16)
        return -1;
6818

6819 6820 6821
    for(i=0; i<sizeof(user_data)-1 && i<size; i++){
        user_data[i]= get_bits(&s->gb, 8);
    }
6822

6823 6824 6825 6826
    user_data[i]= 0;
    e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
    if(e==1 && build>=0)
        h->x264_build= build;
6827

6828 6829 6830 6831 6832
    if(s->avctx->debug & FF_DEBUG_BUGS)
        av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);

    for(; i<size; i++)
        skip_bits(&s->gb, 8);
6833

6834 6835 6836 6837 6838
    return 0;
}

static int decode_sei(H264Context *h){
    MpegEncContext * const s = &h->s;
6839

6840 6841
    while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
        int size, type;
6842

6843 6844 6845 6846
        type=0;
        do{
            type+= show_bits(&s->gb, 8);
        }while(get_bits(&s->gb, 8) == 255);
6847

6848 6849 6850 6851
        size=0;
        do{
            size+= show_bits(&s->gb, 8);
        }while(get_bits(&s->gb, 8) == 255);
6852

6853
        switch(type){
6854 6855 6856 6857
        case 1: // Picture timing SEI
            if(decode_picture_timing(h) < 0)
                return -1;
            break;
6858
        case 5:
michael's avatar
michael committed
6859
            if(decode_unregistered_user_data(h, size) < 0)
6860 6861 6862 6863 6864
                return -1;
            break;
        default:
            skip_bits(&s->gb, 8*size);
        }
6865

6866 6867 6868 6869 6870 6871 6872
        //FIXME check bits here
        align_get_bits(&s->gb);
    }

    return 0;
}

6873
static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
6874 6875 6876
    MpegEncContext * const s = &h->s;
    int cpb_count, i;
    cpb_count = get_ue_golomb(&s->gb) + 1;
6877 6878 6879 6880 6881 6882

    if(cpb_count > 32U){
        av_log(h->s.avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
        return -1;
    }

6883 6884 6885 6886 6887 6888 6889 6890
    get_bits(&s->gb, 4); /* bit_rate_scale */
    get_bits(&s->gb, 4); /* cpb_size_scale */
    for(i=0; i<cpb_count; i++){
        get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
        get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
        get_bits1(&s->gb);     /* cbr_flag */
    }
    get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */
6891 6892 6893
    sps->cpb_removal_delay_length = get_bits(&s->gb, 5) + 1;
    sps->dpb_output_delay_length = get_bits(&s->gb, 5) + 1;
    sps->time_offset_length = get_bits(&s->gb, 5);
6894
    return 0;
6895 6896
}

michaelni's avatar
michaelni committed
6897 6898
static inline int decode_vui_parameters(H264Context *h, SPS *sps){
    MpegEncContext * const s = &h->s;
6899 6900
    int aspect_ratio_info_present_flag;
    unsigned int aspect_ratio_idc;
michaelni's avatar
michaelni committed
6901 6902

    aspect_ratio_info_present_flag= get_bits1(&s->gb);
6903

michaelni's avatar
michaelni committed
6904 6905 6906
    if( aspect_ratio_info_present_flag ) {
        aspect_ratio_idc= get_bits(&s->gb, 8);
        if( aspect_ratio_idc == EXTENDED_SAR ) {
michael's avatar
michael committed
6907 6908
            sps->sar.num= get_bits(&s->gb, 16);
            sps->sar.den= get_bits(&s->gb, 16);
6909
        }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
michael's avatar
michael committed
6910
            sps->sar=  pixel_aspect[aspect_ratio_idc];
michaelni's avatar
michaelni committed
6911
        }else{
6912
            av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
michaelni's avatar
michaelni committed
6913 6914 6915
            return -1;
        }
    }else{
6916
        sps->sar.num=
michael's avatar
michael committed
6917
        sps->sar.den= 0;
michaelni's avatar
michaelni committed
6918 6919
    }
//            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937 6938 6939 6940 6941 6942 6943 6944 6945 6946

    if(get_bits1(&s->gb)){      /* overscan_info_present_flag */
        get_bits1(&s->gb);      /* overscan_appropriate_flag */
    }

    if(get_bits1(&s->gb)){      /* video_signal_type_present_flag */
        get_bits(&s->gb, 3);    /* video_format */
        get_bits1(&s->gb);      /* video_full_range_flag */
        if(get_bits1(&s->gb)){  /* colour_description_present_flag */
            get_bits(&s->gb, 8); /* colour_primaries */
            get_bits(&s->gb, 8); /* transfer_characteristics */
            get_bits(&s->gb, 8); /* matrix_coefficients */
        }
    }

    if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */
        get_ue_golomb(&s->gb);  /* chroma_sample_location_type_top_field */
        get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */
    }

    sps->timing_info_present_flag = get_bits1(&s->gb);
    if(sps->timing_info_present_flag){
        sps->num_units_in_tick = get_bits_long(&s->gb, 32);
        sps->time_scale = get_bits_long(&s->gb, 32);
        sps->fixed_frame_rate_flag = get_bits1(&s->gb);
    }

6947 6948
    sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
    if(sps->nal_hrd_parameters_present_flag)
6949 6950
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
6951 6952
    sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
    if(sps->vcl_hrd_parameters_present_flag)
6953 6954
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
6955
    if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
6956
        get_bits1(&s->gb);     /* low_delay_hrd_flag */
6957
    sps->pic_struct_present_flag = get_bits1(&s->gb);
6958 6959 6960 6961 6962 6963 6964 6965

    sps->bitstream_restriction_flag = get_bits1(&s->gb);
    if(sps->bitstream_restriction_flag){
        get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
        get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
        get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
        get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
        get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
6966
        sps->num_reorder_frames= get_ue_golomb(&s->gb);
6967 6968
        get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/

6969 6970
        if(sps->num_reorder_frames > 16U /*max_dec_frame_buffering || max_dec_frame_buffering > 16*/){
            av_log(h->s.avctx, AV_LOG_ERROR, "illegal num_reorder_frames %d\n", sps->num_reorder_frames);
6971 6972
            return -1;
        }
6973 6974
    }

michaelni's avatar
michaelni committed
6975 6976 6977
    return 0;
}

6978 6979
static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
                                const uint8_t *jvt_list, const uint8_t *fallback_list){
lorenm's avatar
lorenm committed
6980 6981 6982
    MpegEncContext * const s = &h->s;
    int i, last = 8, next = 8;
    const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
6983 6984
    if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
        memcpy(factors, fallback_list, size*sizeof(uint8_t));
lorenm's avatar
lorenm committed
6985 6986 6987 6988
    else
    for(i=0;i<size;i++){
        if(next)
            next = (last + get_se_golomb(&s->gb)) & 0xff;
6989 6990
        if(!i && !next){ /* matrix not written, we use the preset one */
            memcpy(factors, jvt_list, size*sizeof(uint8_t));
lorenm's avatar
lorenm committed
6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008
            break;
        }
        last = factors[scan[i]] = next ? next : last;
    }
}

static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
                                   uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
    MpegEncContext * const s = &h->s;
    int fallback_sps = !is_sps && sps->scaling_matrix_present;
    const uint8_t *fallback[4] = {
        fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
        fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
        fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
        fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
    };
    if(get_bits1(&s->gb)){
        sps->scaling_matrix_present |= is_sps;
7009 7010 7011 7012 7013 7014
        decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
        decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
        decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
        decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
        decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
        decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
lorenm's avatar
lorenm committed
7015
        if(is_sps || pps->transform_8x8_mode){
7016 7017
            decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
            decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]);  // Inter, Y
lorenm's avatar
lorenm committed
7018 7019 7020 7021
        }
    }
}

michaelni's avatar
michaelni committed
7022 7023
static inline int decode_seq_parameter_set(H264Context *h){
    MpegEncContext * const s = &h->s;
michaelni's avatar
michaelni committed
7024
    int profile_idc, level_idc;
7025
    unsigned int sps_id;
7026
    int i;
michaelni's avatar
michaelni committed
7027
    SPS *sps;
7028

michaelni's avatar
michaelni committed
7029
    profile_idc= get_bits(&s->gb, 8);
michaelni's avatar
michaelni committed
7030 7031 7032
    get_bits1(&s->gb);   //constraint_set0_flag
    get_bits1(&s->gb);   //constraint_set1_flag
    get_bits1(&s->gb);   //constraint_set2_flag
michael's avatar
michael committed
7033 7034
    get_bits1(&s->gb);   //constraint_set3_flag
    get_bits(&s->gb, 4); // reserved
michaelni's avatar
michaelni committed
7035 7036
    level_idc= get_bits(&s->gb, 8);
    sps_id= get_ue_golomb(&s->gb);
7037

7038 7039 7040 7041 7042
    if(sps_id >= MAX_SPS_COUNT) {
        av_log(h->s.avctx, AV_LOG_ERROR, "sps_id (%d) out of range\n", sps_id);
        return -1;
    }
    sps= av_mallocz(sizeof(SPS));
benoit's avatar
 
benoit committed
7043
    if(sps == NULL)
7044 7045
        return -1;

michaelni's avatar
michaelni committed
7046 7047
    sps->profile_idc= profile_idc;
    sps->level_idc= level_idc;
michael's avatar
michael committed
7048

7049 7050 7051 7052
    memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
    memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
    sps->scaling_matrix_present = 0;

lorenm's avatar
lorenm committed
7053
    if(sps->profile_idc >= 100){ //high profile
7054 7055
        sps->chroma_format_idc= get_ue_golomb(&s->gb);
        if(sps->chroma_format_idc == 3)
lorenm's avatar
lorenm committed
7056 7057 7058
            get_bits1(&s->gb);  //residual_color_transform_flag
        get_ue_golomb(&s->gb);  //bit_depth_luma_minus8
        get_ue_golomb(&s->gb);  //bit_depth_chroma_minus8
lorenm's avatar
lorenm committed
7059
        sps->transform_bypass = get_bits1(&s->gb);
lorenm's avatar
lorenm committed
7060
        decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
7061 7062 7063
    }else{
        sps->chroma_format_idc= 1;
    }
lorenm's avatar
lorenm committed
7064

michaelni's avatar
michaelni committed
7065 7066
    sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
    sps->poc_type= get_ue_golomb(&s->gb);
7067

michaelni's avatar
michaelni committed
7068 7069 7070 7071 7072 7073
    if(sps->poc_type == 0){ //FIXME #define
        sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
    } else if(sps->poc_type == 1){//FIXME #define
        sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
        sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
        sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
7074
        sps->poc_cycle_length                = get_ue_golomb(&s->gb);
7075

7076 7077
        if((unsigned)sps->poc_cycle_length >= FF_ARRAY_ELEMS(sps->offset_for_ref_frame)){
            av_log(h->s.avctx, AV_LOG_ERROR, "poc_cycle_length overflow %u\n", sps->poc_cycle_length);
7078
            goto fail;
7079
        }
7080

michaelni's avatar
michaelni committed
7081 7082
        for(i=0; i<sps->poc_cycle_length; i++)
            sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
7083
    }else if(sps->poc_type != 2){
7084
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
7085
        goto fail;
michaelni's avatar
michaelni committed
7086 7087
    }

7088 7089
    sps->ref_frame_count= get_ue_golomb(&s->gb);
    if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
7090
        av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
7091
        goto fail;
7092
    }
michaelni's avatar
michaelni committed
7093
    sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
7094 7095 7096 7097
    sps->mb_width = get_ue_golomb(&s->gb) + 1;
    sps->mb_height= get_ue_golomb(&s->gb) + 1;
    if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
       avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height)){
7098
        av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
7099
        goto fail;
7100
    }
7101

michaelni's avatar
michaelni committed
7102 7103 7104 7105 7106 7107 7108 7109
    sps->frame_mbs_only_flag= get_bits1(&s->gb);
    if(!sps->frame_mbs_only_flag)
        sps->mb_aff= get_bits1(&s->gb);
    else
        sps->mb_aff= 0;

    sps->direct_8x8_inference_flag= get_bits1(&s->gb);

lorenm's avatar
lorenm committed
7110 7111
#ifndef ALLOW_INTERLACE
    if(sps->mb_aff)
diego's avatar
diego committed
7112
        av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
lorenm's avatar
lorenm committed
7113
#endif
michaelni's avatar
michaelni committed
7114 7115 7116 7117 7118 7119 7120
    sps->crop= get_bits1(&s->gb);
    if(sps->crop){
        sps->crop_left  = get_ue_golomb(&s->gb);
        sps->crop_right = get_ue_golomb(&s->gb);
        sps->crop_top   = get_ue_golomb(&s->gb);
        sps->crop_bottom= get_ue_golomb(&s->gb);
        if(sps->crop_left || sps->crop_top){
7121
            av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
michaelni's avatar
michaelni committed
7122
        }
7123
        if(sps->crop_right >= 8 || sps->crop_bottom >= (8>> !sps->frame_mbs_only_flag)){
7124 7125
            av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
        }
michaelni's avatar
michaelni committed
7126
    }else{
7127 7128 7129
        sps->crop_left  =
        sps->crop_right =
        sps->crop_top   =
michaelni's avatar
michaelni committed
7130 7131 7132
        sps->crop_bottom= 0;
    }

michaelni's avatar
michaelni committed
7133 7134 7135
    sps->vui_parameters_present_flag= get_bits1(&s->gb);
    if( sps->vui_parameters_present_flag )
        decode_vui_parameters(h, sps);
7136

michaelni's avatar
michaelni committed
7137
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7138
        av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s\n",
michaelni's avatar
michaelni committed
7139 7140 7141 7142 7143 7144
               sps_id, sps->profile_idc, sps->level_idc,
               sps->poc_type,
               sps->ref_frame_count,
               sps->mb_width, sps->mb_height,
               sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
               sps->direct_8x8_inference_flag ? "8B8" : "",
7145 7146
               sps->crop_left, sps->crop_right,
               sps->crop_top, sps->crop_bottom,
7147 7148
               sps->vui_parameters_present_flag ? "VUI" : "",
               ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc]
michaelni's avatar
michaelni committed
7149 7150
               );
    }
7151 7152
    av_free(h->sps_buffers[sps_id]);
    h->sps_buffers[sps_id]= sps;
michaelni's avatar
michaelni committed
7153
    return 0;
7154 7155 7156
fail:
    av_free(sps);
    return -1;
michaelni's avatar
michaelni committed
7157 7158
}

7159
static void
7160
build_qp_table(PPS *pps, int t, int index)
7161 7162
{
    int i;
7163 7164
    for(i = 0; i < 52; i++)
        pps->chroma_qp_table[t][i] = chroma_qp[av_clip(i + index, 0, 51)];
7165 7166
}

lorenm's avatar
lorenm committed
7167
static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
michaelni's avatar
michaelni committed
7168
    MpegEncContext * const s = &h->s;
7169
    unsigned int pps_id= get_ue_golomb(&s->gb);
7170 7171
    PPS *pps;

7172 7173
    if(pps_id >= MAX_PPS_COUNT) {
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
7174
        return -1;
7175
    }
7176

7177 7178 7179
    pps= av_mallocz(sizeof(PPS));
    if(pps == NULL)
        return -1;
7180 7181 7182 7183 7184
    pps->sps_id= get_ue_golomb(&s->gb);
    if((unsigned)pps->sps_id>=MAX_SPS_COUNT || h->sps_buffers[pps->sps_id] == NULL){
        av_log(h->s.avctx, AV_LOG_ERROR, "sps_id out of range\n");
        goto fail;
    }
7185

michaelni's avatar
michaelni committed
7186 7187 7188 7189 7190
    pps->cabac= get_bits1(&s->gb);
    pps->pic_order_present= get_bits1(&s->gb);
    pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
    if(pps->slice_group_count > 1 ){
        pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
7191
        av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
michaelni's avatar
michaelni committed
7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222
        switch(pps->mb_slice_group_map_type){
        case 0:
#if 0
|   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
|    run_length[ i ]                                |1  |ue(v)   |
#endif
            break;
        case 2:
#if 0
|   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
|{                                                  |   |        |
|    top_left_mb[ i ]                               |1  |ue(v)   |
|    bottom_right_mb[ i ]                           |1  |ue(v)   |
|   }                                               |   |        |
#endif
            break;
        case 3:
        case 4:
        case 5:
#if 0
|   slice_group_change_direction_flag               |1  |u(1)    |
|   slice_group_change_rate_minus1                  |1  |ue(v)   |
#endif
            break;
        case 6:
#if 0
|   slice_group_id_cnt_minus1                       |1  |ue(v)   |
|   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
|)                                                  |   |        |
|    slice_group_id[ i ]                            |1  |u(v)    |
#endif
7223
            break;
michaelni's avatar
michaelni committed
7224 7225 7226 7227
        }
    }
    pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
    pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
michael's avatar
michael committed
7228
    if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
7229
        av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
7230
        goto fail;
michaelni's avatar
michaelni committed
7231
    }
7232

michaelni's avatar
michaelni committed
7233 7234 7235 7236
    pps->weighted_pred= get_bits1(&s->gb);
    pps->weighted_bipred_idc= get_bits(&s->gb, 2);
    pps->init_qp= get_se_golomb(&s->gb) + 26;
    pps->init_qs= get_se_golomb(&s->gb) + 26;
7237
    pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
michaelni's avatar
michaelni committed
7238 7239 7240
    pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
    pps->constrained_intra_pred= get_bits1(&s->gb);
    pps->redundant_pic_cnt_present = get_bits1(&s->gb);
7241

7242 7243
    pps->transform_8x8_mode= 0;
    h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
7244 7245
    memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4, sizeof(pps->scaling_matrix4));
    memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
lorenm's avatar
lorenm committed
7246 7247 7248

    if(get_bits_count(&s->gb) < bit_length){
        pps->transform_8x8_mode= get_bits1(&s->gb);
benoit's avatar
 
benoit committed
7249
        decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
7250 7251 7252
        pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
    } else {
        pps->chroma_qp_index_offset[1]= pps->chroma_qp_index_offset[0];
lorenm's avatar
lorenm committed
7253
    }
7254

7255
    build_qp_table(pps, 0, pps->chroma_qp_index_offset[0]);
7256 7257
    build_qp_table(pps, 1, pps->chroma_qp_index_offset[1]);
    if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
7258 7259
        h->pps.chroma_qp_diff= 1;

michaelni's avatar
michaelni committed
7260
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7261
        av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%u sps:%u %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d/%d %s %s %s %s\n",
michaelni's avatar
michaelni committed
7262 7263 7264 7265 7266
               pps_id, pps->sps_id,
               pps->cabac ? "CABAC" : "CAVLC",
               pps->slice_group_count,
               pps->ref_count[0], pps->ref_count[1],
               pps->weighted_pred ? "weighted" : "",
7267
               pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
michaelni's avatar
michaelni committed
7268 7269
               pps->deblocking_filter_parameters_present ? "LPAR" : "",
               pps->constrained_intra_pred ? "CONSTR" : "",
lorenm's avatar
lorenm committed
7270 7271
               pps->redundant_pic_cnt_present ? "REDU" : "",
               pps->transform_8x8_mode ? "8x8DCT" : ""
michaelni's avatar
michaelni committed
7272 7273
               );
    }
7274

7275 7276
    av_free(h->pps_buffers[pps_id]);
    h->pps_buffers[pps_id]= pps;
michaelni's avatar
michaelni committed
7277
    return 0;
7278 7279 7280
fail:
    av_free(pps);
    return -1;
michaelni's avatar
michaelni committed
7281 7282
}

7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295
/**
 * Call decode_slice() for each context.
 *
 * @param h h264 master context
 * @param context_count number of contexts to execute
 */
static void execute_decode_slices(H264Context *h, int context_count){
    MpegEncContext * const s = &h->s;
    AVCodecContext * const avctx= s->avctx;
    H264Context *hx;
    int i;

    if(context_count == 1) {
cehoyos's avatar
cehoyos committed
7296
        decode_slice(avctx, &h);
7297 7298 7299
    } else {
        for(i = 1; i < context_count; i++) {
            hx = h->thread_context[i];
7300
            hx->s.error_recognition = avctx->error_recognition;
7301 7302 7303 7304
            hx->s.error_count = 0;
        }

        avctx->execute(avctx, (void *)decode_slice,
7305
                       (void **)h->thread_context, NULL, context_count, sizeof(void*));
7306 7307 7308 7309 7310

        /* pull back stuff from slices to master context */
        hx = h->thread_context[context_count - 1];
        s->mb_x = hx->s.mb_x;
        s->mb_y = hx->s.mb_y;
7311 7312
        s->dropable = hx->s.dropable;
        s->picture_structure = hx->s.picture_structure;
7313 7314 7315 7316 7317 7318
        for(i = 1; i < context_count; i++)
            h->s.error_count += h->thread_context[i]->s.error_count;
    }
}


michael's avatar
michael committed
7319
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
michaelni's avatar
michaelni committed
7320 7321 7322
    MpegEncContext * const s = &h->s;
    AVCodecContext * const avctx= s->avctx;
    int buf_index=0;
7323 7324 7325 7326
    H264Context *hx; ///< thread context
    int context_count = 0;

    h->max_contexts = avctx->thread_count;
michaelni's avatar
michaelni committed
7327
#if 0
al3x's avatar
al3x committed
7328
    int i;
7329 7330
    for(i=0; i<50; i++){
        av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
michaelni's avatar
michaelni committed
7331 7332
    }
#endif
7333
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
7334
        h->current_slice = 0;
7335
        if (!s->first_field)
andoma's avatar
andoma committed
7336
            s->current_picture_ptr= NULL;
7337 7338
    }

michaelni's avatar
michaelni committed
7339 7340 7341 7342
    for(;;){
        int consumed;
        int dst_length;
        int bit_length;
michael's avatar
michael committed
7343
        const uint8_t *ptr;
7344
        int i, nalsize = 0;
7345
        int err;
7346

benoit's avatar
benoit committed
7347 7348 7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366
        if(h->is_avc) {
            if(buf_index >= buf_size) break;
            nalsize = 0;
            for(i = 0; i < h->nal_length_size; i++)
                nalsize = (nalsize << 8) | buf[buf_index++];
            if(nalsize <= 1 || (nalsize+buf_index > buf_size)){
                if(nalsize == 1){
                    buf_index++;
                    continue;
                }else{
                    av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
                    break;
                }
            }
        } else {
            // start code prefix search
            for(; buf_index + 3 < buf_size; buf_index++){
                // This should always succeed in the first iteration.
                if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
                    break;
7367
            }
7368

benoit's avatar
benoit committed
7369
            if(buf_index+3 >= buf_size) break;
7370

benoit's avatar
benoit committed
7371 7372
            buf_index+=3;
        }
7373

7374 7375 7376
        hx = h->thread_context[context_count];

        ptr= decode_nal(hx, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
7377
        if (ptr==NULL || dst_length < 0){
7378 7379
            return -1;
        }
7380
        while(ptr[dst_length - 1] == 0 && dst_length > 0)
7381
            dst_length--;
7382
        bit_length= !dst_length ? 0 : (8*dst_length - decode_rbsp_trailing(h, ptr + dst_length - 1));
michaelni's avatar
michaelni committed
7383 7384

        if(s->avctx->debug&FF_DEBUG_STARTCODE){
7385
            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);
michaelni's avatar
michaelni committed
7386
        }
7387

7388
        if (h->is_avc && (nalsize != consumed)){
7389
            av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
7390 7391
            consumed= nalsize;
        }
7392

michaelni's avatar
michaelni committed
7393 7394
        buf_index += consumed;

diego's avatar
diego committed
7395
        if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME do not discard SEI id
michael's avatar
michael committed
7396
           ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))
michaelni's avatar
michaelni committed
7397
            continue;
7398

7399 7400 7401
      again:
        err = 0;
        switch(hx->nal_unit_type){
michaelni's avatar
michaelni committed
7402
        case NAL_IDR_SLICE:
7403 7404 7405 7406
            if (h->nal_unit_type != NAL_IDR_SLICE) {
                av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");
                return -1;
            }
7407
            idr(h); //FIXME ensure we don't loose some frames if there is reordering
michaelni's avatar
michaelni committed
7408
        case NAL_SLICE:
7409 7410 7411 7412 7413 7414 7415 7416
            init_get_bits(&hx->s.gb, ptr, bit_length);
            hx->intra_gb_ptr=
            hx->inter_gb_ptr= &hx->s.gb;
            hx->s.data_partitioning = 0;

            if((err = decode_slice_header(hx, h)))
               break;

7417
            s->current_picture_ptr->key_frame|= (hx->nal_unit_type == NAL_IDR_SLICE);
7418 7419
            if(hx->redundant_pic_count==0 && hx->s.hurry_up < 5
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
7420
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)
7421
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
michael's avatar
michael committed
7422
               && avctx->skip_frame < AVDISCARD_ALL)
7423
                context_count++;
michaelni's avatar
michaelni committed
7424 7425
            break;
        case NAL_DPA:
7426 7427 7428 7429
            init_get_bits(&hx->s.gb, ptr, bit_length);
            hx->intra_gb_ptr=
            hx->inter_gb_ptr= NULL;
            hx->s.data_partitioning = 1;
7430

7431
            err = decode_slice_header(hx, h);
michaelni's avatar
michaelni committed
7432 7433
            break;
        case NAL_DPB:
7434 7435
            init_get_bits(&hx->intra_gb, ptr, bit_length);
            hx->intra_gb_ptr= &hx->intra_gb;
michaelni's avatar
michaelni committed
7436 7437
            break;
        case NAL_DPC:
7438 7439
            init_get_bits(&hx->inter_gb, ptr, bit_length);
            hx->inter_gb_ptr= &hx->inter_gb;
michaelni's avatar
michaelni committed
7440

7441
            if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning
7442
               && s->context_initialized
michael's avatar
michael committed
7443
               && s->hurry_up < 5
7444
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
7445
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)
7446
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
michael's avatar
michael committed
7447
               && avctx->skip_frame < AVDISCARD_ALL)
7448
                context_count++;
michaelni's avatar
michaelni committed
7449 7450
            break;
        case NAL_SEI:
7451 7452
            init_get_bits(&s->gb, ptr, bit_length);
            decode_sei(h);
michaelni's avatar
michaelni committed
7453 7454 7455 7456
            break;
        case NAL_SPS:
            init_get_bits(&s->gb, ptr, bit_length);
            decode_seq_parameter_set(h);
7457

michaelni's avatar
michaelni committed
7458 7459
            if(s->flags& CODEC_FLAG_LOW_DELAY)
                s->low_delay=1;
7460

7461 7462
            if(avctx->has_b_frames < 2)
                avctx->has_b_frames= !s->low_delay;
michaelni's avatar
michaelni committed
7463 7464 7465
            break;
        case NAL_PPS:
            init_get_bits(&s->gb, ptr, bit_length);
7466

lorenm's avatar
lorenm committed
7467
            decode_picture_parameter_set(h, bit_length);
michaelni's avatar
michaelni committed
7468 7469

            break;
lorenm's avatar
lorenm committed
7470 7471 7472 7473 7474 7475
        case NAL_AUD:
        case NAL_END_SEQUENCE:
        case NAL_END_STREAM:
        case NAL_FILLER_DATA:
        case NAL_SPS_EXT:
        case NAL_AUXILIARY_SLICE:
michaelni's avatar
michaelni committed
7476
            break;
7477
        default:
7478
            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", h->nal_unit_type, bit_length);
7479 7480
        }

7481 7482 7483 7484 7485 7486 7487 7488 7489 7490
        if(context_count == h->max_contexts) {
            execute_decode_slices(h, context_count);
            context_count = 0;
        }

        if (err < 0)
            av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
        else if(err == 1) {
            /* Slice could not be decoded in parallel mode, copy down
             * NAL unit stuff to context 0 and restart. Note that
diego's avatar
diego committed
7491
             * rbsp_buffer is not transferred, but since we no longer
7492 7493 7494 7495 7496 7497 7498 7499 7500
             * run in parallel mode this should not be an issue. */
            h->nal_unit_type = hx->nal_unit_type;
            h->nal_ref_idc   = hx->nal_ref_idc;
            hx = h;
            goto again;
        }
    }
    if(context_count)
        execute_decode_slices(h, context_count);
michaelni's avatar
michaelni committed
7501 7502 7503 7504
    return buf_index;
}

/**
7505
 * returns the number of bytes consumed for building the current frame
michaelni's avatar
michaelni committed
7506 7507
 */
static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
diego's avatar
diego committed
7508
        if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
michaelni's avatar
michaelni committed
7509 7510 7511 7512 7513
        if(pos+10>buf_size) pos=buf_size; // oops ;)

        return pos;
}

7514
static int decode_frame(AVCodecContext *avctx,
michaelni's avatar
michaelni committed
7515
                             void *data, int *data_size,
michael's avatar
michael committed
7516
                             const uint8_t *buf, int buf_size)
michaelni's avatar
michaelni committed
7517 7518 7519
{
    H264Context *h = avctx->priv_data;
    MpegEncContext *s = &h->s;
7520
    AVFrame *pict = data;
michaelni's avatar
michaelni committed
7521
    int buf_index;
7522

michaelni's avatar
michaelni committed
7523
    s->flags= avctx->flags;
7524
    s->flags2= avctx->flags2;
michaelni's avatar
michaelni committed
7525

diego's avatar
diego committed
7526
   /* end of stream, output what is still in the buffers */
michaelni's avatar
michaelni committed
7527
    if (buf_size == 0) {
michael's avatar
michael committed
7528 7529 7530 7531 7532 7533
        Picture *out;
        int i, out_idx;

//FIXME factorize this with the output code below
        out = h->delayed_pic[0];
        out_idx = 0;
7534
        for(i=1; h->delayed_pic[i] && (h->delayed_pic[i]->poc && !h->delayed_pic[i]->key_frame); i++)
michael's avatar
michael committed
7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547
            if(h->delayed_pic[i]->poc < out->poc){
                out = h->delayed_pic[i];
                out_idx = i;
            }

        for(i=out_idx; h->delayed_pic[i]; i++)
            h->delayed_pic[i] = h->delayed_pic[i+1];

        if(out){
            *data_size = sizeof(AVFrame);
            *pict= *(AVFrame*)out;
        }

michaelni's avatar
michaelni committed
7548 7549
        return 0;
    }
7550

7551 7552 7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568
    if(h->is_avc && !h->got_avcC) {
        int i, cnt, nalsize;
        unsigned char *p = avctx->extradata;
        if(avctx->extradata_size < 7) {
            av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
            return -1;
        }
        if(*p != 1) {
            av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);
            return -1;
        }
        /* sps and pps in the avcC always have length coded with 2 bytes,
           so put a fake nal_length_size = 2 while parsing them */
        h->nal_length_size = 2;
        // Decode sps from avcC
        cnt = *(p+5) & 0x1f; // Number of sps
        p += 6;
        for (i = 0; i < cnt; i++) {
7569
            nalsize = AV_RB16(p) + 2;
7570
            if(decode_nal_units(h, p, nalsize) < 0) {
7571 7572 7573 7574
                av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
                return -1;
            }
            p += nalsize;
7575
        }
7576 7577 7578
        // Decode pps from avcC
        cnt = *(p++); // Number of pps
        for (i = 0; i < cnt; i++) {
7579
            nalsize = AV_RB16(p) + 2;
7580 7581 7582 7583 7584
            if(decode_nal_units(h, p, nalsize)  != nalsize) {
                av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
                return -1;
            }
            p += nalsize;
7585
        }
7586 7587 7588 7589 7590 7591
        // Now store right nal length size, that will be use to parse all other nals
        h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
        // Do not reparse avcC
        h->got_avcC = 1;
    }

7592
    if(!h->got_avcC && !h->is_avc && s->avctx->extradata_size){
7593
        if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
michaelni's avatar
michaelni committed
7594
            return -1;
7595
        h->got_avcC = 1;
michaelni's avatar
michaelni committed
7596 7597 7598
    }

    buf_index=decode_nal_units(h, buf, buf_size);
7599
    if(buf_index < 0)
michaelni's avatar
michaelni committed
7600 7601
        return -1;

7602
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){
7603
        if (avctx->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0;
7604 7605 7606 7607
        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
        return -1;
    }

7608 7609 7610 7611
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){
        Picture *out = s->current_picture_ptr;
        Picture *cur = s->current_picture_ptr;
        int i, pics, cross_idr, out_of_order, out_idx;
7612

7613 7614 7615 7616 7617
        s->mb_y= 0;

        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
        s->current_picture_ptr->pict_type= s->pict_type;

7618
        if(!s->dropable) {
michael's avatar
michael committed
7619
            execute_ref_pic_marking(h, h->mmco, h->mmco_index);
7620 7621
            h->prev_poc_msb= h->poc_msb;
            h->prev_poc_lsb= h->poc_lsb;
7622
        }
michael's avatar
michael committed
7623 7624
        h->prev_frame_num_offset= h->frame_num_offset;
        h->prev_frame_num= h->frame_num;
7625

7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638
        /*
         * FIXME: Error handling code does not seem to support interlaced
         * when slices span multiple rows
         * The ff_er_add_slice calls don't work right for bottom
         * fields; they cause massive erroneous error concealing
         * Error marking covers both fields (top and bottom).
         * This causes a mismatched s->error_count
         * and a bad error table. Further, the error count goes to
         * INT_MAX when called for bottom field, because mb_y is
         * past end by one (callers fault) and resync_mb_y != 0
         * causes problems for the first MB line, too.
         */
        if (!FIELD_PICTURE)
andoma's avatar
andoma committed
7639
            ff_er_frame_end(s);
7640 7641 7642

        MPV_frame_end(s);

7643
        if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
7644 7645 7646 7647
            /* Wait for second field. */
            *data_size = 0;

        } else {
7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701
            cur->repeat_pict = 0;

            /* Signal interlacing information externally. */
            /* Prioritize picture timing SEI information over used decoding process if it exists. */
            if(h->sps.pic_struct_present_flag){
                switch (h->sei_pic_struct)
                {
                case SEI_PIC_STRUCT_FRAME:
                    cur->interlaced_frame = 0;
                    break;
                case SEI_PIC_STRUCT_TOP_FIELD:
                case SEI_PIC_STRUCT_BOTTOM_FIELD:
                case SEI_PIC_STRUCT_TOP_BOTTOM:
                case SEI_PIC_STRUCT_BOTTOM_TOP:
                    cur->interlaced_frame = 1;
                    break;
                case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
                case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
                    // Signal the possibility of telecined film externally (pic_struct 5,6)
                    // From these hints, let the applications decide if they apply deinterlacing.
                    cur->repeat_pict = 1;
                    cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
                    break;
                case SEI_PIC_STRUCT_FRAME_DOUBLING:
                    // Force progressive here, as doubling interlaced frame is a bad idea.
                    cur->interlaced_frame = 0;
                    cur->repeat_pict = 2;
                    break;
                case SEI_PIC_STRUCT_FRAME_TRIPLING:
                    cur->interlaced_frame = 0;
                    cur->repeat_pict = 4;
                    break;
                }
            }else{
                /* Derive interlacing flag from used decoding process. */
                cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
            }

            if (cur->field_poc[0] != cur->field_poc[1]){
                /* Derive top_field_first from field pocs. */
                cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
            }else{
                if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
                    /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
                    if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
                      || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
                        cur->top_field_first = 1;
                    else
                        cur->top_field_first = 0;
                }else{
                    /* Most likely progressive */
                    cur->top_field_first = 0;
                }
            }
7702

andoma's avatar
andoma committed
7703
        //FIXME do something with unavailable reference frames
michaelni's avatar
michaelni committed
7704

andoma's avatar
andoma committed
7705
            /* Sort B-frames into display order */
7706

andoma's avatar
andoma committed
7707 7708 7709 7710 7711
            if(h->sps.bitstream_restriction_flag
               && s->avctx->has_b_frames < h->sps.num_reorder_frames){
                s->avctx->has_b_frames = h->sps.num_reorder_frames;
                s->low_delay = 0;
            }
7712

7713 7714 7715 7716 7717 7718
            if(   s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
               && !h->sps.bitstream_restriction_flag){
                s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
                s->low_delay= 0;
            }

andoma's avatar
andoma committed
7719 7720
            pics = 0;
            while(h->delayed_pic[pics]) pics++;
7721

7722
            assert(pics <= MAX_DELAYED_PIC_COUNT);
7723

andoma's avatar
andoma committed
7724 7725 7726
            h->delayed_pic[pics++] = cur;
            if(cur->reference == 0)
                cur->reference = DELAYED_PIC_REF;
7727

andoma's avatar
andoma committed
7728 7729
            out = h->delayed_pic[0];
            out_idx = 0;
7730
            for(i=1; h->delayed_pic[i] && (h->delayed_pic[i]->poc && !h->delayed_pic[i]->key_frame); i++)
andoma's avatar
andoma committed
7731 7732 7733 7734
                if(h->delayed_pic[i]->poc < out->poc){
                    out = h->delayed_pic[i];
                    out_idx = i;
                }
7735
            cross_idr = !h->delayed_pic[0]->poc || !!h->delayed_pic[i] || h->delayed_pic[0]->key_frame;
lorenm's avatar
lorenm committed
7736

7737
            out_of_order = !cross_idr && out->poc < h->outputed_poc;
7738

andoma's avatar
andoma committed
7739 7740
            if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
                { }
7741
            else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
andoma's avatar
andoma committed
7742
               || (s->low_delay &&
7743
                ((!cross_idr && out->poc > h->outputed_poc + 2)
7744
                 || cur->pict_type == FF_B_TYPE)))
andoma's avatar
andoma committed
7745 7746 7747 7748 7749 7750
            {
                s->low_delay = 0;
                s->avctx->has_b_frames++;
            }

            if(out_of_order || pics > s->avctx->has_b_frames){
michael's avatar
michael committed
7751
                out->reference &= ~DELAYED_PIC_REF;
andoma's avatar
andoma committed
7752 7753 7754
                for(i=out_idx; h->delayed_pic[i]; i++)
                    h->delayed_pic[i] = h->delayed_pic[i+1];
            }
michael's avatar
michael committed
7755
            if(!out_of_order && pics > s->avctx->has_b_frames){
andoma's avatar
andoma committed
7756
                *data_size = sizeof(AVFrame);
7757 7758

                h->outputed_poc = out->poc;
andoma's avatar
andoma committed
7759
                *pict= *(AVFrame*)out;
michael's avatar
michael committed
7760
            }else{
andoma's avatar
andoma committed
7761
                av_log(avctx, AV_LOG_DEBUG, "no picture\n");
michael's avatar
michael committed
7762
            }
7763
        }
lorenm's avatar
lorenm committed
7764 7765
    }

7766
    assert(pict->data[0] || !*data_size);
7767
    ff_print_debug_info(s, pict);
michaelni's avatar
michaelni committed
7768 7769 7770 7771
//printf("out %d\n", (int)pict->data[0]);
#if 0 //?

    /* Return the Picture timestamp as the frame number */
vitor's avatar
vitor committed
7772
    /* we subtract 1 because it is added on utils.c     */
michaelni's avatar
michaelni committed
7773 7774 7775 7776 7777 7778 7779
    avctx->frame_number = s->picture_number - 1;
#endif
    return get_consumed_bytes(s, buf_index, buf_size);
}
#if 0
static inline void fill_mb_avail(H264Context *h){
    MpegEncContext * const s = &h->s;
7780
    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
michaelni's avatar
michaelni committed
7781 7782

    if(s->mb_y){
7783 7784 7785
        h->mb_avail[0]= s->mb_x                 && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
        h->mb_avail[1]=                            h->slice_table[mb_xy - s->mb_stride    ] == h->slice_num;
        h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
michaelni's avatar
michaelni committed
7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796
    }else{
        h->mb_avail[0]=
        h->mb_avail[1]=
        h->mb_avail[2]= 0;
    }
    h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
    h->mb_avail[4]= 1; //FIXME move out
    h->mb_avail[5]= 0; //FIXME move out
}
#endif

7797
#ifdef TEST
7798
#undef printf
7799
#undef random
michaelni's avatar
michaelni committed
7800 7801
#define COUNT 8000
#define SIZE (COUNT*40)
diego's avatar
diego committed
7802
int main(void){
michaelni's avatar
michaelni committed
7803 7804 7805 7806 7807 7808 7809
    int i;
    uint8_t temp[SIZE];
    PutBitContext pb;
    GetBitContext gb;
//    int int_temp[10000];
    DSPContext dsp;
    AVCodecContext avctx;
7810

michaelni's avatar
michaelni committed
7811 7812
    dsputil_init(&dsp, &avctx);

7813
    init_put_bits(&pb, temp, SIZE);
michaelni's avatar
michaelni committed
7814 7815 7816 7817 7818 7819 7820
    printf("testing unsigned exp golomb\n");
    for(i=0; i<COUNT; i++){
        START_TIMER
        set_ue_golomb(&pb, i);
        STOP_TIMER("set_ue_golomb");
    }
    flush_put_bits(&pb);
7821

michaelni's avatar
michaelni committed
7822 7823 7824
    init_get_bits(&gb, temp, 8*SIZE);
    for(i=0; i<COUNT; i++){
        int j, s;
7825

michaelni's avatar
michaelni committed
7826
        s= show_bits(&gb, 24);
7827

michaelni's avatar
michaelni committed
7828 7829 7830
        START_TIMER
        j= get_ue_golomb(&gb);
        if(j != i){
diego's avatar
diego committed
7831
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
michaelni's avatar
michaelni committed
7832 7833 7834 7835
//            return -1;
        }
        STOP_TIMER("get_ue_golomb");
    }
7836 7837


alex's avatar
10l  
alex committed
7838
    init_put_bits(&pb, temp, SIZE);
michaelni's avatar
michaelni committed
7839 7840 7841 7842 7843 7844 7845
    printf("testing signed exp golomb\n");
    for(i=0; i<COUNT; i++){
        START_TIMER
        set_se_golomb(&pb, i - COUNT/2);
        STOP_TIMER("set_se_golomb");
    }
    flush_put_bits(&pb);
7846

michaelni's avatar
michaelni committed
7847 7848 7849
    init_get_bits(&gb, temp, 8*SIZE);
    for(i=0; i<COUNT; i++){
        int j, s;
7850

michaelni's avatar
michaelni committed
7851
        s= show_bits(&gb, 24);
7852

michaelni's avatar
michaelni committed
7853 7854 7855
        START_TIMER
        j= get_se_golomb(&gb);
        if(j != i - COUNT/2){
diego's avatar
diego committed
7856
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
michaelni's avatar
michaelni committed
7857 7858 7859 7860 7861
//            return -1;
        }
        STOP_TIMER("get_se_golomb");
    }

7862
#if 0
michaelni's avatar
michaelni committed
7863
    printf("testing 4x4 (I)DCT\n");
7864

michaelni's avatar
michaelni committed
7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877
    DCTELEM block[16];
    uint8_t src[16], ref[16];
    uint64_t error= 0, max_error=0;

    for(i=0; i<COUNT; i++){
        int j;
//        printf("%d %d %d\n", r1, r2, (r2-r1)*16);
        for(j=0; j<16; j++){
            ref[j]= random()%255;
            src[j]= random()%255;
        }

        h264_diff_dct_c(block, src, ref, 4);
7878

michaelni's avatar
michaelni committed
7879 7880 7881 7882 7883 7884 7885 7886
        //normalize
        for(j=0; j<16; j++){
//            printf("%d ", block[j]);
            block[j]= block[j]*4;
            if(j&1) block[j]= (block[j]*4 + 2)/5;
            if(j&4) block[j]= (block[j]*4 + 2)/5;
        }
//        printf("\n");
7887

7888
        s->dsp.h264_idct_add(ref, block, 4);
michaelni's avatar
michaelni committed
7889 7890 7891 7892
/*        for(j=0; j<16; j++){
            printf("%d ", ref[j]);
        }
        printf("\n");*/
7893

michaelni's avatar
michaelni committed
7894
        for(j=0; j<16; j++){
diego's avatar
diego committed
7895
            int diff= FFABS(src[j] - ref[j]);
7896

michaelni's avatar
michaelni committed
7897 7898 7899 7900 7901 7902 7903 7904 7905
            error+= diff*diff;
            max_error= FFMAX(max_error, diff);
        }
    }
    printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
    printf("testing quantizer\n");
    for(qp=0; qp<52; qp++){
        for(i=0; i<16; i++)
            src1_block[i]= src2_block[i]= random()%255;
7906

michaelni's avatar
michaelni committed
7907 7908
    }
    printf("Testing NAL layer\n");
7909

michaelni's avatar
michaelni committed
7910 7911 7912 7913
    uint8_t bitstream[COUNT];
    uint8_t nal[COUNT*2];
    H264Context h;
    memset(&h, 0, sizeof(H264Context));
7914

michaelni's avatar
michaelni committed
7915 7916 7917 7918 7919 7920 7921
    for(i=0; i<COUNT; i++){
        int zeros= i;
        int nal_length;
        int consumed;
        int out_length;
        uint8_t *out;
        int j;
7922

michaelni's avatar
michaelni committed
7923 7924 7925
        for(j=0; j<COUNT; j++){
            bitstream[j]= (random() % 255) + 1;
        }
7926

michaelni's avatar
michaelni committed
7927 7928 7929 7930 7931 7932 7933 7934
        for(j=0; j<zeros; j++){
            int pos= random() % COUNT;
            while(bitstream[pos] == 0){
                pos++;
                pos %= COUNT;
            }
            bitstream[pos]=0;
        }
7935

michaelni's avatar
michaelni committed
7936
        START_TIMER
7937

michaelni's avatar
michaelni committed
7938 7939 7940 7941 7942
        nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
        if(nal_length<0){
            printf("encoding failed\n");
            return -1;
        }
7943

michaelni's avatar
michaelni committed
7944 7945 7946
        out= decode_nal(&h, nal, &out_length, &consumed, nal_length);

        STOP_TIMER("NAL")
7947

michaelni's avatar
michaelni committed
7948 7949 7950 7951
        if(out_length != COUNT){
            printf("incorrect length %d %d\n", out_length, COUNT);
            return -1;
        }
7952

michaelni's avatar
michaelni committed
7953 7954 7955 7956
        if(consumed != nal_length){
            printf("incorrect consumed length %d %d\n", nal_length, consumed);
            return -1;
        }
7957

michaelni's avatar
michaelni committed
7958
        if(memcmp(bitstream, out, COUNT)){
diego's avatar
diego committed
7959
            printf("mismatch\n");
michaelni's avatar
michaelni committed
7960 7961 7962
            return -1;
        }
    }
7963
#endif
7964

michaelni's avatar
michaelni committed
7965
    printf("Testing RBSP\n");
7966 7967


michaelni's avatar
michaelni committed
7968 7969
    return 0;
}
7970
#endif /* TEST */
michaelni's avatar
michaelni committed
7971 7972


7973
static av_cold int decode_end(AVCodecContext *avctx)
michaelni's avatar
michaelni committed
7974 7975 7976
{
    H264Context *h = avctx->priv_data;
    MpegEncContext *s = &h->s;
7977
    int i;
7978

7979 7980
    av_freep(&h->rbsp_buffer[0]);
    av_freep(&h->rbsp_buffer[1]);
michaelni's avatar
michaelni committed
7981
    free_tables(h); //FIXME cleanup init stuff perhaps
7982 7983 7984 7985 7986 7987 7988

    for(i = 0; i < MAX_SPS_COUNT; i++)
        av_freep(h->sps_buffers + i);

    for(i = 0; i < MAX_PPS_COUNT; i++)
        av_freep(h->pps_buffers + i);

michaelni's avatar
michaelni committed
7989 7990 7991
    MPV_common_end(s);

//    memset(h, 0, sizeof(H264Context));
7992

michaelni's avatar
michaelni committed
7993 7994 7995 7996 7997 7998 7999 8000 8001 8002 8003 8004 8005
    return 0;
}


AVCodec h264_decoder = {
    "h264",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H264,
    sizeof(H264Context),
    decode_init,
    NULL,
    decode_end,
    decode_frame,
8006
    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY,
lorenm's avatar
lorenm committed
8007
    .flush= flush_dpb,
8008
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
michaelni's avatar
michaelni committed
8009 8010
};

michaelni's avatar
michaelni committed
8011
#include "svq3.c"