h264.c 307 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
    bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
1409
    h->rbsp_buffer[bufidx]= av_fast_realloc(h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
1410
    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
            }else //next start code
                break;
        }

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

1433 1434
    memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);

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

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

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

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

/**
diego's avatar
diego committed
1459
 * IDCT transforms the 16 dc values and dequantizes them.
michaelni's avatar
michaelni committed
1460 1461
 * @param qp quantization parameter
 */
lorenm's avatar
lorenm committed
1462
static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
michaelni's avatar
michaelni committed
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 1489 1490
#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
1491
        block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual
lorenm's avatar
lorenm committed
1492 1493 1494
        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
1495 1496 1497
    }
}

1498
#if 0
michaelni's avatar
michaelni committed
1499
/**
diego's avatar
diego committed
1500
 * DCT transforms the 16 dc values.
michaelni's avatar
michaelni committed
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 1534 1535
 * @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;
    }
}
1536 1537
#endif

michaelni's avatar
michaelni committed
1538 1539 1540
#undef xStride
#undef stride

lorenm's avatar
lorenm committed
1541
static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
michaelni's avatar
michaelni committed
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
    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
1556 1557 1558 1559
    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
1560 1561
}

1562
#if 0
michaelni's avatar
michaelni committed
1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
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);
}
1583
#endif
michaelni's avatar
michaelni committed
1584 1585 1586 1587

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

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
1598
    int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
michaelni's avatar
michaelni committed
1599
    const int luma_xy= (mx&3) + ((my&3)<<2);
lorenm's avatar
lorenm committed
1600 1601 1602 1603
    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
1604 1605 1606
    int emu=0;
    const int full_mx= mx>>2;
    const int full_my= my>>2;
1607
    const int pic_width  = 16*s->mb_width;
1608
    const int pic_height = 16*s->mb_height >> MB_FIELD;
1609

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

    if(   full_mx < 0-extra_width
       || full_my < 0-extra_height
       || full_mx + 16/*FIXME*/ > pic_width + extra_width
1616
       || full_my + 16/*FIXME*/ > pic_height + extra_height){
lorenm's avatar
lorenm committed
1617 1618
        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
1619 1620
        emu=1;
    }
1621

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

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

1629
    if(MB_FIELD){
lorenm's avatar
lorenm committed
1630
        // chroma offset when predicting from a field of opposite parity
1631
        my += 2 * ((s->mb_y & 1) - (pic->reference - 1));
lorenm's avatar
lorenm committed
1632 1633 1634 1635 1636
        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
1637
    if(emu){
lorenm's avatar
lorenm committed
1638
        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
1639 1640
            src_cb= s->edge_emu_buffer;
    }
lorenm's avatar
lorenm committed
1641
    chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
michaelni's avatar
michaelni committed
1642 1643

    if(emu){
lorenm's avatar
lorenm committed
1644
        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
1645 1646
            src_cr= s->edge_emu_buffer;
    }
lorenm's avatar
lorenm committed
1647
    chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
michaelni's avatar
michaelni committed
1648 1649
}

lorenm's avatar
lorenm committed
1650
static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
michaelni's avatar
michaelni committed
1651 1652 1653 1654 1655 1656 1657 1658
                           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;
1659

lorenm's avatar
lorenm committed
1660 1661 1662
    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
1663
    x_offset += 8*s->mb_x;
1664
    y_offset += 8*(s->mb_y >> MB_FIELD);
1665

michaelni's avatar
michaelni committed
1666
    if(list0){
1667
        Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
michaelni's avatar
michaelni committed
1668 1669 1670 1671 1672 1673 1674 1675 1676
        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){
1677
        Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
michaelni's avatar
michaelni committed
1678 1679 1680 1681 1682 1683
        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
1684 1685 1686 1687 1688 1689 1690 1691 1692
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
1693 1694 1695
    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
1696
    x_offset += 8*s->mb_x;
1697
    y_offset += 8*(s->mb_y >> MB_FIELD);
1698

lorenm's avatar
lorenm committed
1699 1700 1701 1702
    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
1703 1704
        uint8_t *tmp_cr = s->obmc_scratchpad + 8;
        uint8_t *tmp_y  = s->obmc_scratchpad + 8*h->mb_uvlinesize;
lorenm's avatar
lorenm committed
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
        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
1718 1719 1720
            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
1721
        }else{
lorenm's avatar
lorenm committed
1722
            luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
1723
                            h->luma_weight[0][refn0], h->luma_weight[1][refn1],
lorenm's avatar
lorenm committed
1724
                            h->luma_offset[0][refn0] + h->luma_offset[1][refn1]);
lorenm's avatar
lorenm committed
1725
            chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1726
                            h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
lorenm's avatar
lorenm committed
1727
                            h->chroma_offset[0][refn0][0] + h->chroma_offset[1][refn1][0]);
lorenm's avatar
lorenm committed
1728
            chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
1729
                            h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
lorenm's avatar
lorenm committed
1730
                            h->chroma_offset[0][refn0][1] + h->chroma_offset[1][refn1][1]);
lorenm's avatar
lorenm committed
1731 1732 1733 1734 1735 1736 1737 1738 1739
        }
    }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
1740
        luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
lorenm's avatar
lorenm committed
1741 1742
                       h->luma_weight[list][refn], h->luma_offset[list][refn]);
        if(h->use_weight_chroma){
lorenm's avatar
lorenm committed
1743
            chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
lorenm's avatar
lorenm committed
1744
                             h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
lorenm's avatar
lorenm committed
1745
            chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
lorenm's avatar
lorenm committed
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
                             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,
1756
                           h264_weight_func *weight_op, h264_biweight_func *weight_avg,
lorenm's avatar
lorenm committed
1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
                           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);
}

1769 1770 1771 1772 1773 1774 1775 1776 1777
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
1778
        int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64;
1779 1780 1781 1782 1783 1784
        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
1785 1786
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
1787 1788
                      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
1789
    MpegEncContext * const s = &h->s;
1790
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
1791
    const int mb_type= s->current_picture.mb_type[mb_xy];
1792

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

1795 1796
    prefetch_motion(h, 0);

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

michaelni's avatar
michaelni committed
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833
        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
1834
                    &weight_op[3], &weight_avg[3],
michaelni's avatar
michaelni committed
1835 1836 1837 1838
                    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
1839
                    &weight_op[4], &weight_avg[4],
michaelni's avatar
michaelni committed
1840 1841 1842
                    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
1843
                    &weight_op[4], &weight_avg[4],
michaelni's avatar
michaelni committed
1844 1845
                    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
1846
                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
1847
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
lorenm's avatar
lorenm committed
1848
                    &weight_op[5], &weight_avg[5],
michaelni's avatar
michaelni committed
1849
                    IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
lorenm's avatar
lorenm committed
1850
                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
1851
                    qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
lorenm's avatar
lorenm committed
1852
                    &weight_op[5], &weight_avg[5],
michaelni's avatar
michaelni committed
1853 1854 1855 1856 1857 1858 1859 1860 1861
                    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
1862
                        &weight_op[6], &weight_avg[6],
michaelni's avatar
michaelni committed
1863 1864 1865 1866 1867
                        IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
                }
            }
        }
    }
1868 1869

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

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

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

cehoyos's avatar
cehoyos committed
1880 1881
        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;
1882
        init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
michaelni's avatar
michaelni committed
1883
                 &chroma_dc_coeff_token_len [0], 1, 1,
cehoyos's avatar
cehoyos committed
1884 1885
                 &chroma_dc_coeff_token_bits[0], 1, 1,
                 INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1886

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

        for(i=0; i<3; i++){
cehoyos's avatar
cehoyos committed
1905 1906 1907 1908
            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
1909
                     &chroma_dc_total_zeros_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1910 1911
                     &chroma_dc_total_zeros_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1912 1913
        }
        for(i=0; i<15; i++){
cehoyos's avatar
cehoyos committed
1914 1915 1916 1917
            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
1918
                     &total_zeros_len [i][0], 1, 1,
cehoyos's avatar
cehoyos committed
1919 1920
                     &total_zeros_bits[i][0], 1, 1,
                     INIT_VLC_USE_NEW_STATIC);
michaelni's avatar
michaelni committed
1921 1922 1923
        }

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

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

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

1957 1958 1959 1960 1961 1962 1963
    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
1964 1965
}

lorenm's avatar
lorenm committed
1966 1967
static void init_dequant8_coeff_table(H264Context *h){
    int i,q,x;
lorenm's avatar
lorenm committed
1968
    const int transpose = (h->s.dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly
lorenm's avatar
lorenm committed
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
    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++){
1979 1980
            int shift = div6[q];
            int idx = rem6[q];
lorenm's avatar
lorenm committed
1981
            for(x=0; x<64; x++)
lorenm's avatar
lorenm committed
1982 1983 1984
                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
1985 1986 1987 1988 1989 1990
        }
    }
}

static void init_dequant4_coeff_table(H264Context *h){
    int i,j,q,x;
1991
    const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
lorenm's avatar
lorenm committed
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
    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++){
2004 2005
            int shift = div6[q] + 2;
            int idx = rem6[q];
lorenm's avatar
lorenm committed
2006
            for(x=0; x<16; x++)
2007 2008
                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
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030
                    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
2031 2032
/**
 * allocates tables.
2033
 * needs width/height
michaelni's avatar
michaelni committed
2034 2035 2036
 */
static int alloc_tables(H264Context *h){
    MpegEncContext * const s = &h->s;
2037
    const int big_mb_num= s->mb_stride * (s->mb_height+1);
lorenm's avatar
lorenm committed
2038
    int x,y;
michaelni's avatar
michaelni committed
2039 2040

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

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

2046 2047 2048 2049
    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));
2050

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

2054 2055
    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
2056 2057
    for(y=0; y<s->mb_height; y++){
        for(x=0; x<s->mb_width; x++){
2058
            const int mb_xy= x + y*s->mb_stride;
michaelni's avatar
michaelni committed
2059 2060
            const int b_xy = 4*x + 4*y*h->b_stride;
            const int b8_xy= 2*x + 2*y*h->b8_stride;
2061

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

2067 2068
    s->obmc_scratchpad = NULL;

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

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

2078 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
/**
 * 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
}

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

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

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

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

2123 2124
    dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early

2125 2126
    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
2127 2128
}

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

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

michaelni's avatar
michaelni committed
2135 2136 2137 2138 2139 2140 2141 2142
    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;
2143
    s->quarter_sample = 1;
michaelni's avatar
michaelni committed
2144
    s->low_delay= 1;
2145 2146 2147 2148

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

2151
    decode_init_vlc();
2152

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

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

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

2171 2172
    if(MPV_frame_start(s, s->avctx) < 0)
        return -1;
michaelni's avatar
michaelni committed
2173
    ff_er_frame_start(s);
2174 2175 2176
    /*
     * 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
2177
     * Zero here; IDR markings per slice in frame or fields are ORed in later.
2178 2179 2180
     * See decode_nal_units().
     */
    s->current_picture_ptr->key_frame= 0;
michaelni's avatar
michaelni committed
2181 2182 2183 2184 2185

    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);
2186
        h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
michaelni's avatar
michaelni committed
2187 2188 2189 2190
    }
    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);
2191 2192
        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
2193 2194
    }

2195 2196
    /* can't be in alloc_tables because linesize isn't known there.
     * FIXME: redo bipred weight to not require extra buffer? */
2197 2198 2199
    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
2200 2201

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

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

diego's avatar
diego committed
2207
    // We mark the current picture as non-reference after allocating it, so
2208 2209 2210 2211 2212 2213 2214
    // 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;
2215 2216 2217

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

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

2223
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){
2224 2225
    MpegEncContext * const s = &h->s;
    int i;
2226 2227 2228 2229 2230
    int step    = 1;
    int offset  = 1;
    int uvoffset= 1;
    int top_idx = 1;
    int skiplast= 0;
2231

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

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 2263
    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;
    }

2264
    // There are two lines saved, the line above the the top macroblock of a pair,
2265
    // and the line above the bottom macroblock
2266 2267 2268
    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];
2269
    }
2270

2271 2272
    *(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);
2273

michael's avatar
michael committed
2274
    if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2275 2276 2277 2278 2279
        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];
2280
        }
2281 2282
        *(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);
2283 2284 2285
    }
}

2286
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){
2287 2288 2289
    MpegEncContext * const s = &h->s;
    int temp8, i;
    uint64_t temp64;
2290 2291 2292
    int deblock_left;
    int deblock_top;
    int mb_xy;
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
    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;
    }
2309 2310

    if(h->deblocking_filter == 2) {
2311
        mb_xy = h->mb_xy;
2312 2313 2314 2315
        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);
2316
        deblock_top =  (s->mb_y > !!MB_FIELD);
2317
    }
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327

    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;
2328 2329

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

    if(deblock_top){
2337 2338
        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
2339
        if(s->mb_x+1 < s->mb_width){
2340
            XCHG(*(uint64_t*)(h->top_borders[top_idx][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
lorenm's avatar
lorenm committed
2341
        }
2342 2343
    }

michael's avatar
michael committed
2344
    if(simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2345
        if(deblock_left){
2346 2347 2348
            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);
2349
            }
2350 2351
            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);
2352 2353
        }
        if(deblock_top){
2354 2355
            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);
2356 2357 2358 2359
        }
    }
}

2360
static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){
michaelni's avatar
michaelni committed
2361 2362 2363
    MpegEncContext * const s = &h->s;
    const int mb_x= s->mb_x;
    const int mb_y= s->mb_y;
2364
    const int mb_xy= h->mb_xy;
michaelni's avatar
michaelni committed
2365 2366 2367 2368
    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;
2369
    int *block_offset = &h->block_offset[0];
michael's avatar
michael committed
2370 2371
    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
2372
    void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
2373
    void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
michaelni's avatar
michaelni committed
2374

2375 2376 2377
    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
2378

lorenm's avatar
lorenm committed
2379 2380 2381
    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);

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

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

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

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

michael's avatar
michael committed
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483
                            if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
                                h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize);
                            }else{
                                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;
2484
                                }else
michael's avatar
michael committed
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
                                    topright= NULL;

                                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);
                                }
2498
                            }
michael's avatar
michael committed
2499
                        }
michaelni's avatar
michaelni committed
2500
                    }
michaelni's avatar
michaelni committed
2501
                }
2502
            }else{
2503
                h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
2504
                if(is_h264){
lorenm's avatar
lorenm committed
2505
                    if(!transform_bypass)
takis's avatar
takis committed
2506
                        h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]);
lorenm's avatar
lorenm committed
2507
                }else
2508
                    svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
michaelni's avatar
michaelni committed
2509
            }
2510
            if(h->deblocking_filter)
2511
                xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple);
2512
        }else if(is_h264){
2513
            hl_motion(h, dest_y, dest_cb, dest_cr,
2514 2515
                      s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
                      s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
2516
                      s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
michaelni's avatar
michaelni committed
2517
        }
2518 2519 2520


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

2562
        if((simple || !ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
2563 2564
            uint8_t *dest[2] = {dest_cb, dest_cr};
            if(transform_bypass){
2565 2566 2567 2568
                if(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{
2569
                    idct_add = s->dsp.add_pixels4;
2570 2571 2572 2573 2574
                    for(i=16; i<16+8; i++){
                        if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16])
                            idct_add   (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize);
                    }
                }
2575
            }else{
2576 2577
                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]);
michael's avatar
michael committed
2578
                if(is_h264){
2579 2580
                    idct_add = s->dsp.h264_idct_add;
                    idct_dc_add = s->dsp.h264_idct_dc_add;
2581 2582 2583 2584 2585 2586
                    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
2587 2588 2589 2590 2591 2592
                }else{
                    for(i=16; i<16+8; i++){
                        if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
                            uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
                            svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
                        }
2593
                    }
michaelni's avatar
michaelni committed
2594
                }
michaelni's avatar
michaelni committed
2595 2596 2597
            }
        }
    }
2598 2599 2600
    if(h->cbp || IS_INTRA(mb_type))
        s->dsp.clear_blocks(h->mb);

2601
    if(h->deblocking_filter) {
2602 2603 2604 2605
        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]);
2606
        if (!simple && FRAME_MBAFF) {
2607
            filter_mb     (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2608
        } else {
2609
            filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2610
        }
2611
    }
michaelni's avatar
michaelni committed
2612 2613
}

2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
/**
 * 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;
2630
    const int mb_xy= h->mb_xy;
2631
    const int mb_type= s->current_picture.mb_type[mb_xy];
2632
    int is_complex = ENABLE_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
2633

2634
    if(ENABLE_H264_ENCODER && !s->decode)
2635 2636 2637 2638 2639 2640 2641
        return;

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

2642
static void pic_as_field(Picture *pic, const int parity){
2643 2644
    int i;
    for (i = 0; i < 4; ++i) {
2645
        if (parity == PICT_BOTTOM_FIELD)
2646
            pic->data[i] += pic->linesize[i];
2647
        pic->reference = parity;
2648 2649
        pic->linesize[i] *= 2;
    }
2650
    pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD];
2651 2652 2653 2654 2655 2656 2657 2658
}

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

    if (match) {
        *dest = *src;
2659
        if(parity != PICT_FRAME){
michael's avatar
michael committed
2660 2661 2662
            pic_as_field(dest, parity);
            dest->pic_id *= 2;
            dest->pic_id += id_add;
2663
        }
2664 2665 2666 2667 2668
    }

    return match;
}

2669 2670 2671
static int build_def_list(Picture *def, Picture **in, int len, int is_long, int sel){
    int i[2]={0};
    int index=0;
2672

2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684
    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);
2685 2686 2687
        }
    }

2688
    return index;
2689 2690
}

2691 2692 2693
static int add_sorted(Picture **sorted, Picture **src, int len, int limit, int dir){
    int i, best_poc;
    int out_i= 0;
2694

2695 2696
    for(;;){
        best_poc= dir ? INT_MIN : INT_MAX;
2697

2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
        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;
2710 2711
}

michaelni's avatar
michaelni committed
2712 2713 2714 2715 2716
/**
 * fills the default_ref_list.
 */
static int fill_default_ref_list(H264Context *h){
    MpegEncContext * const s = &h->s;
2717
    int i, len;
2718

2719
    if(h->slice_type_nos==FF_B_TYPE){
2720 2721 2722
        Picture *sorted[32];
        int cur_poc, list;
        int lens[2];
2723

2724 2725 2726 2727
        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;
2728

2729 2730 2731 2732 2733 2734 2735
        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);
2736

2737 2738 2739
            if(len < h->ref_count[list])
                memset(&h->default_ref_list[list][len], 0, sizeof(Picture)*(h->ref_count[list] - len));
            lens[list]= len;
2740 2741
        }

2742 2743 2744 2745
        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]);
2746 2747
        }
    }else{
2748 2749 2750 2751 2752
        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
2753
    }
2754 2755
#ifdef TRACE
    for (i=0; i<h->ref_count[0]; i++) {
mbardiaux's avatar
mbardiaux committed
2756
        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]);
2757
    }
2758
    if(h->slice_type_nos==FF_B_TYPE){
2759
        for (i=0; i<h->ref_count[1]; i++) {
2760
            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]);
2761 2762 2763
        }
    }
#endif
michaelni's avatar
michaelni committed
2764 2765 2766
    return 0;
}

2767 2768 2769
static void print_short_term(H264Context *h);
static void print_long_term(H264Context *h);

2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793
/**
 * 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
2794 2795
static int decode_ref_pic_list_reordering(H264Context *h){
    MpegEncContext * const s = &h->s;
2796
    int list, index, pic_structure;
2797

2798 2799
    print_short_term(h);
    print_long_term(h);
2800

2801
    for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
2802 2803 2804 2805 2806 2807
        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++){
2808 2809
                unsigned int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
                unsigned int pic_id;
michaelni's avatar
michaelni committed
2810
                int i;
2811
                Picture *ref = NULL;
2812 2813

                if(reordering_of_pic_nums_idc==3)
2814
                    break;
2815

michaelni's avatar
michaelni committed
2816
                if(index >= h->ref_count[list]){
2817
                    av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
michaelni's avatar
michaelni committed
2818 2819
                    return -1;
                }
2820

michaelni's avatar
michaelni committed
2821 2822
                if(reordering_of_pic_nums_idc<3){
                    if(reordering_of_pic_nums_idc<2){
2823
                        const unsigned int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
2824
                        int frame_num;
michaelni's avatar
michaelni committed
2825

2826
                        if(abs_diff_pic_num > h->max_pic_num){
2827
                            av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
michaelni's avatar
michaelni committed
2828 2829 2830 2831 2832 2833
                            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;
2834

2835 2836
                        frame_num = pic_num_extract(h, pred, &pic_structure);

2837 2838
                        for(i= h->short_ref_count-1; i>=0; i--){
                            ref = h->short_ref[i];
2839
                            assert(ref->reference);
2840
                            assert(!ref->long_ref);
2841
                            if(
michael's avatar
michael committed
2842 2843
                                   ref->frame_num == frame_num &&
                                   (ref->reference & pic_structure)
2844
                              )
michaelni's avatar
michaelni committed
2845 2846
                                break;
                        }
2847
                        if(i>=0)
2848
                            ref->pic_id= pred;
michaelni's avatar
michaelni committed
2849
                    }else{
2850
                        int long_idx;
michaelni's avatar
michaelni committed
2851
                        pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
2852 2853 2854 2855

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

                        if(long_idx>31){
2856 2857 2858
                            av_log(h->s.avctx, AV_LOG_ERROR, "long_term_pic_idx overflow\n");
                            return -1;
                        }
2859 2860
                        ref = h->long_ref[long_idx];
                        assert(!(ref && !ref->reference));
michael's avatar
michael committed
2861
                        if(ref && (ref->reference & pic_structure)){
2862 2863 2864 2865 2866 2867
                            ref->pic_id= pic_id;
                            assert(ref->long_ref);
                            i=0;
                        }else{
                            i=-1;
                        }
michaelni's avatar
michaelni committed
2868 2869
                    }

2870
                    if (i < 0) {
2871
                        av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
michaelni's avatar
michaelni committed
2872
                        memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
2873 2874 2875 2876
                    } 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;
2877 2878 2879 2880
                        }
                        for(; i > index; i--){
                            h->ref_list[list][i]= h->ref_list[list][i-1];
                        }
2881
                        h->ref_list[list][index]= *ref;
2882
                        if (FIELD_PICTURE){
2883
                            pic_as_field(&h->ref_list[list][index], pic_structure);
2884
                        }
michaelni's avatar
michaelni committed
2885
                    }
2886
                }else{
2887
                    av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
michaelni's avatar
michaelni committed
2888 2889 2890 2891 2892
                    return -1;
                }
            }
        }
    }
2893
    for(list=0; list<h->list_count; list++){
2894
        for(index= 0; index < h->ref_count[list]; index++){
2895 2896 2897 2898
            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
            }
2899 2900
        }
    }
2901 2902

    return 0;
michaelni's avatar
michaelni committed
2903 2904
}

2905
static void fill_mbaff_ref_list(H264Context *h){
lorenm's avatar
lorenm committed
2906
    int list, i, j;
2907
    for(list=0; list<2; list++){ //FIXME try list_count
lorenm's avatar
lorenm committed
2908 2909 2910 2911 2912 2913
        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;
2914
            field[0].reference = PICT_TOP_FIELD;
2915
            field[0].poc= field[0].field_poc[0];
lorenm's avatar
lorenm committed
2916 2917 2918
            field[1] = field[0];
            for(j=0; j<3; j++)
                field[1].data[j] += frame->linesize[j];
2919
            field[1].reference = PICT_BOTTOM_FIELD;
2920
            field[1].poc= field[1].field_poc[1];
lorenm's avatar
lorenm committed
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937

            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
2938 2939 2940
static int pred_weight_table(H264Context *h){
    MpegEncContext * const s = &h->s;
    int list, i;
lorenm's avatar
lorenm committed
2941
    int luma_def, chroma_def;
2942

lorenm's avatar
lorenm committed
2943 2944
    h->use_weight= 0;
    h->use_weight_chroma= 0;
michaelni's avatar
michaelni committed
2945 2946
    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
2947 2948
    luma_def = 1<<h->luma_log2_weight_denom;
    chroma_def = 1<<h->chroma_log2_weight_denom;
michaelni's avatar
michaelni committed
2949 2950 2951 2952

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

michaelni's avatar
michaelni committed
2954 2955 2956 2957
            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
2958 2959 2960 2961 2962 2963
                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
2964 2965
            }

2966
            if(CHROMA){
michael's avatar
michael committed
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
                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
2983 2984 2985
                }
            }
        }
2986
        if(h->slice_type_nos != FF_B_TYPE) break;
michaelni's avatar
michaelni committed
2987
    }
lorenm's avatar
lorenm committed
2988
    h->use_weight= h->use_weight || h->use_weight_chroma;
michaelni's avatar
michaelni committed
2989 2990 2991
    return 0;
}

lorenm's avatar
lorenm committed
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
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
3012
            int poc1 = h->ref_list[1][ref1].poc;
reimar's avatar
reimar committed
3013
            int td = av_clip(poc1 - poc0, -128, 127);
lorenm's avatar
lorenm committed
3014
            if(td){
reimar's avatar
reimar committed
3015
                int tb = av_clip(cur_poc - poc0, -128, 127);
diego's avatar
diego committed
3016
                int tx = (16384 + (FFABS(td) >> 1)) / td;
reimar's avatar
reimar committed
3017
                int dist_scale_factor = av_clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
lorenm's avatar
lorenm committed
3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
                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;
        }
    }
}

3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039
/**
 * 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){
3040
    int i;
3041 3042 3043
    if (pic->reference &= refmask) {
        return 0;
    } else {
michael's avatar
michael committed
3044 3045 3046 3047 3048
        for(i = 0; h->delayed_pic[i]; i++)
            if(pic == h->delayed_pic[i]){
                pic->reference=DELAYED_PIC_REF;
                break;
            }
3049 3050
        return 1;
    }
3051 3052
}

michaelni's avatar
michaelni committed
3053
/**
michael's avatar
michael committed
3054
 * instantaneous decoder refresh.
michaelni's avatar
michaelni committed
3055 3056
 */
static void idr(H264Context *h){
3057
    int i;
michaelni's avatar
michaelni committed
3058

3059
    for(i=0; i<16; i++){
3060
        remove_long(h, i, 0);
michaelni's avatar
michaelni committed
3061
    }
3062
    assert(h->long_ref_count==0);
michaelni's avatar
michaelni committed
3063 3064

    for(i=0; i<h->short_ref_count; i++){
3065
        unreference_pic(h, h->short_ref[i], 0);
michaelni's avatar
michaelni committed
3066 3067 3068
        h->short_ref[i]= NULL;
    }
    h->short_ref_count=0;
3069
    h->prev_frame_num= 0;
michael's avatar
michael committed
3070 3071 3072
    h->prev_frame_num_offset= 0;
    h->prev_poc_msb=
    h->prev_poc_lsb= 0;
michaelni's avatar
michaelni committed
3073 3074
}

lorenm's avatar
lorenm committed
3075 3076 3077 3078
/* forget old pics after a seek */
static void flush_dpb(AVCodecContext *avctx){
    H264Context *h= avctx->priv_data;
    int i;
3079
    for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
lorenm's avatar
lorenm committed
3080 3081
        if(h->delayed_pic[i])
            h->delayed_pic[i]->reference= 0;
lorenm's avatar
lorenm committed
3082
        h->delayed_pic[i]= NULL;
lorenm's avatar
lorenm committed
3083
    }
3084
    h->outputed_poc= INT_MIN;
lorenm's avatar
lorenm committed
3085
    idr(h);
3086 3087
    if(h->s.current_picture_ptr)
        h->s.current_picture_ptr->reference= 0;
3088
    h->s.first_field= 0;
3089
    ff_mpeg_flush(avctx);
lorenm's avatar
lorenm committed
3090 3091
}

michaelni's avatar
michaelni committed
3092
/**
3093 3094 3095 3096 3097 3098
 * 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
3099
 */
3100
static Picture * find_short(H264Context *h, int frame_num, int *idx){
3101
    MpegEncContext * const s = &h->s;
michaelni's avatar
michaelni committed
3102
    int i;
3103

michaelni's avatar
michaelni committed
3104 3105
    for(i=0; i<h->short_ref_count; i++){
        Picture *pic= h->short_ref[i];
3106
        if(s->avctx->debug&FF_DEBUG_MMCO)
3107
            av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
3108 3109
        if(pic->frame_num == frame_num) {
            *idx = i;
michaelni's avatar
michaelni committed
3110 3111 3112 3113 3114 3115
            return pic;
        }
    }
    return NULL;
}

3116 3117 3118 3119 3120 3121 3122
/**
 * 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){
3123
    assert(i >= 0 && i < h->short_ref_count);
3124 3125 3126 3127 3128 3129 3130 3131 3132
    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
 */
3133
static Picture * remove_short(H264Context *h, int frame_num, int ref_mask){
3134 3135 3136 3137 3138 3139 3140 3141
    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);
3142 3143
    if (pic){
        if(unreference_pic(h, pic, ref_mask))
3144
        remove_short_at_index(h, i);
3145
    }
3146 3147 3148 3149

    return pic;
}

3150 3151
/**
 * Remove a picture from the long term reference list by its index in
3152
 * that list.
3153
 * @return the removed picture or NULL if an error occurs
michaelni's avatar
michaelni committed
3154
 */
3155
static Picture * remove_long(H264Context *h, int i, int ref_mask){
michaelni's avatar
michaelni committed
3156 3157 3158
    Picture *pic;

    pic= h->long_ref[i];
3159
    if (pic){
3160 3161 3162 3163 3164 3165
        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--;
        }
3166
    }
michaelni's avatar
michaelni committed
3167 3168 3169 3170

    return pic;
}

3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200
/**
 * 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
3201 3202 3203 3204 3205
/**
 * 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;
3206
    int i, j;
3207
    int current_ref_assigned=0;
michaelni's avatar
michaelni committed
3208
    Picture *pic;
3209

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

michaelni's avatar
michaelni committed
3213
    for(i=0; i<mmco_count; i++){
3214
        int structure, frame_num;
michaelni's avatar
michaelni committed
3215
        if(s->avctx->debug&FF_DEBUG_MMCO)
3216
            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
3217

3218 3219 3220 3221 3222
        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){
3223 3224
                if(mmco[i].opcode != MMCO_SHORT2LONG || !h->long_ref[mmco[i].long_arg]
                   || h->long_ref[mmco[i].long_arg]->frame_num != frame_num)
3225 3226 3227 3228 3229
                av_log(h->s.avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
                continue;
            }
        }

michaelni's avatar
michaelni committed
3230 3231
        switch(mmco[i].opcode){
        case MMCO_SHORT2UNUSED:
3232 3233
            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);
3234
            remove_short(h, frame_num, structure ^ PICT_FRAME);
michaelni's avatar
michaelni committed
3235 3236
            break;
        case MMCO_SHORT2LONG:
3237 3238
                if (h->long_ref[mmco[i].long_arg] != pic)
                    remove_long(h, mmco[i].long_arg, 0);
3239

3240 3241
                remove_short_at_index(h, j);
                h->long_ref[ mmco[i].long_arg ]= pic;
3242 3243 3244 3245
                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
3246 3247
            break;
        case MMCO_LONG2UNUSED:
3248 3249 3250
            j = pic_num_extract(h, mmco[i].long_arg, &structure);
            pic = h->long_ref[j];
            if (pic) {
3251
                remove_long(h, j, structure ^ PICT_FRAME);
3252 3253
            } 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
3254 3255
            break;
        case MMCO_LONG:
3256
                    // Comment below left from previous code as it is an interresting note.
3257 3258
                    /* First field in pair is in short term list or
                     * at a different long term index.
3259
                     * This is not allowed; see 7.4.3.3, notes 2 and 3.
3260 3261 3262 3263
                     * Report the problem and keep the pair where it is,
                     * and mark this field valid.
                     */

3264
            if (h->long_ref[mmco[i].long_arg] != s->current_picture_ptr) {
3265
                remove_long(h, mmco[i].long_arg, 0);
3266

3267 3268 3269
                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++;
3270
            }
3271

3272
            s->current_picture_ptr->reference |= s->picture_structure;
3273
            current_ref_assigned=1;
michaelni's avatar
michaelni committed
3274 3275
            break;
        case MMCO_SET_MAX_LONG:
3276
            assert(mmco[i].long_arg <= 16);
3277
            // just remove the long term which index is greater than new max
3278
            for(j = mmco[i].long_arg; j<16; j++){
3279
                remove_long(h, j, 0);
michaelni's avatar
michaelni committed
3280 3281 3282 3283
            }
            break;
        case MMCO_RESET:
            while(h->short_ref_count){
3284
                remove_short(h, h->short_ref[0]->frame_num, 0);
michaelni's avatar
michaelni committed
3285
            }
3286
            for(j = 0; j < 16; j++) {
3287
                remove_long(h, j, 0);
michaelni's avatar
michaelni committed
3288
            }
michael's avatar
michael committed
3289 3290 3291 3292 3293 3294
            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
3295
            s->current_picture_ptr->frame_num= 0;
michaelni's avatar
michaelni committed
3296 3297 3298 3299
            break;
        default: assert(0);
        }
    }
3300

3301
    if (!current_ref_assigned) {
3302 3303 3304 3305
        /* 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
3306
         * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
3307 3308 3309 3310 3311 3312 3313 3314 3315 3316
         */
        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 {
3317
            pic= remove_short(h, s->current_picture_ptr->frame_num, 0);
michael's avatar
michael committed
3318 3319 3320
            if(pic){
                av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
            }
3321

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

michael's avatar
michael committed
3325 3326 3327 3328
            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
3329
    }
3330

3331
    if (h->long_ref_count + h->short_ref_count > h->sps.ref_frame_count){
3332 3333 3334 3335 3336 3337 3338 3339 3340

        /* 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
3341
        if (h->long_ref_count && !h->short_ref_count) {
3342 3343 3344 3345 3346
            for (i = 0; i < 16; ++i)
                if (h->long_ref[i])
                    break;

            assert(i < 16);
3347
            remove_long(h, i, 0);
3348
        } else {
3349
            pic = h->short_ref[h->short_ref_count - 1];
3350
            remove_short(h, pic->frame_num, 0);
3351 3352 3353
        }
    }

3354 3355
    print_short_term(h);
    print_long_term(h);
3356
    return 0;
michaelni's avatar
michaelni committed
3357 3358
}

3359
static int decode_ref_pic_marking(H264Context *h, GetBitContext *gb){
michaelni's avatar
michaelni committed
3360 3361
    MpegEncContext * const s = &h->s;
    int i;
3362

3363
    h->mmco_index= 0;
michaelni's avatar
michaelni committed
3364
    if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
3365
        s->broken_link= get_bits1(gb) -1;
3366
        if(get_bits1(gb)){
michaelni's avatar
michaelni committed
3367
            h->mmco[0].opcode= MMCO_LONG;
3368
            h->mmco[0].long_arg= 0;
michaelni's avatar
michaelni committed
3369
            h->mmco_index= 1;
3370
        }
michaelni's avatar
michaelni committed
3371
    }else{
3372
        if(get_bits1(gb)){ // adaptive_ref_pic_marking_mode_flag
3373
            for(i= 0; i<MAX_MMCO_COUNT; i++) {
3374
                MMCOOpcode opcode= get_ue_golomb(gb);
michaelni's avatar
michaelni committed
3375 3376 3377

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

3393
                if(opcode > (unsigned)MMCO_LONG){
3394
                    av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
michaelni's avatar
michaelni committed
3395 3396
                    return -1;
                }
3397 3398
                if(opcode == MMCO_END)
                    break;
michaelni's avatar
michaelni committed
3399 3400 3401 3402 3403
            }
            h->mmco_index= i;
        }else{
            assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);

3404
            if(h->short_ref_count && h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count &&
3405
                    !(FIELD_PICTURE && !s->first_field && s->current_picture_ptr->reference)) {
michaelni's avatar
michaelni committed
3406
                h->mmco[0].opcode= MMCO_SHORT2UNUSED;
3407
                h->mmco[0].short_pic_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
michaelni's avatar
michaelni committed
3408
                h->mmco_index= 1;
3409 3410 3411 3412 3413 3414
                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
3415
            }
michaelni's avatar
michaelni committed
3416 3417
        }
    }
3418 3419

    return 0;
michaelni's avatar
michaelni committed
3420 3421 3422 3423 3424 3425
}

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];
3426
    Picture *cur = s->current_picture_ptr;
michaelni's avatar
michaelni committed
3427

3428
    h->frame_num_offset= h->prev_frame_num_offset;
3429
    if(h->frame_num < h->prev_frame_num)
3430
        h->frame_num_offset += max_frame_num;
michaelni's avatar
michaelni committed
3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441

    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);
3442
        field_poc[0] =
michaelni's avatar
michaelni committed
3443
        field_poc[1] = h->poc_msb + h->poc_lsb;
3444
        if(s->picture_structure == PICT_FRAME)
michaelni's avatar
michaelni committed
3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456
            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--;
3457

michaelni's avatar
michaelni committed
3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471
        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;

3472
        if(h->nal_ref_idc == 0)
michaelni's avatar
michaelni committed
3473
            expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
3474

michaelni's avatar
michaelni committed
3475 3476 3477 3478 3479 3480
        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{
3481
        int poc= 2*(h->frame_num_offset + h->frame_num);
3482

3483 3484
        if(!h->nal_ref_idc)
            poc--;
3485

michaelni's avatar
michaelni committed
3486 3487 3488
        field_poc[0]= poc;
        field_poc[1]= poc;
    }
3489

3490
    if(s->picture_structure != PICT_BOTTOM_FIELD)
michaelni's avatar
michaelni committed
3491
        s->current_picture_ptr->field_poc[0]= field_poc[0];
3492
    if(s->picture_structure != PICT_TOP_FIELD)
michaelni's avatar
michaelni committed
3493
        s->current_picture_ptr->field_poc[1]= field_poc[1];
3494
    cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
michaelni's avatar
michaelni committed
3495 3496 3497 3498

    return 0;
}

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 3540 3541 3542 3543 3544 3545 3546 3547

/**
 * 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;
    }
}
3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558

/**
 * 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;
3559
    dst->s.first_field          = src->s.first_field;
3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570

    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));
3571 3572 3573

    memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
    memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
3574 3575
}

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

3595
    s->dropable= h->nal_ref_idc == 0;
michaelni's avatar
michaelni committed
3596

3597 3598 3599 3600 3601 3602 3603 3604
    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
3605 3606
    first_mb_in_slice= get_ue_golomb(&s->gb);

3607
    if((s->flags2 & CODEC_FLAG2_CHUNKS) && first_mb_in_slice == 0){
3608
        h0->current_slice = 0;
3609
        if (!s0->first_field)
andoma's avatar
andoma committed
3610
            s->current_picture_ptr= NULL;
3611 3612
    }

3613 3614
    slice_type= get_ue_golomb(&s->gb);
    if(slice_type > 9){
3615
        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
3616
        return -1;
michaelni's avatar
michaelni committed
3617
    }
3618 3619
    if(slice_type > 4){
        slice_type -= 5;
michaelni's avatar
michaelni committed
3620 3621 3622
        h->slice_type_fixed=1;
    }else
        h->slice_type_fixed=0;
3623

3624
    slice_type= golomb_to_pict_type[ slice_type ];
3625
    if (slice_type == FF_I_TYPE
3626
        || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
3627 3628 3629
        default_ref_list_done = 1;
    }
    h->slice_type= slice_type;
michael's avatar
michael committed
3630
    h->slice_type_nos= slice_type & 3;
3631

diego's avatar
diego committed
3632
    s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
3633
    if (s->pict_type == FF_B_TYPE && s0->last_picture_ptr == NULL) {
3634 3635 3636 3637
        av_log(h->s.avctx, AV_LOG_ERROR,
               "B picture before any references, skipping\n");
        return -1;
    }
3638

michaelni's avatar
michaelni committed
3639
    pps_id= get_ue_golomb(&s->gb);
3640
    if(pps_id>=MAX_PPS_COUNT){
3641
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
michaelni's avatar
michaelni committed
3642 3643
        return -1;
    }
3644
    if(!h0->pps_buffers[pps_id]) {
diego's avatar
diego committed
3645
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS referenced\n");
michaelni's avatar
michaelni committed
3646 3647
        return -1;
    }
3648
    h->pps= *h0->pps_buffers[pps_id];
michaelni's avatar
michaelni committed
3649

3650
    if(!h0->sps_buffers[h->pps.sps_id]) {
diego's avatar
diego committed
3651
        av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS referenced\n");
michaelni's avatar
michaelni committed
3652 3653
        return -1;
    }
3654
    h->sps = *h0->sps_buffers[h->pps.sps_id];
lorenm's avatar
lorenm committed
3655

3656
    if(h == h0 && h->dequant_coeff_pps != pps_id){
3657
        h->dequant_coeff_pps = pps_id;
lorenm's avatar
lorenm committed
3658 3659
        init_dequant_tables(h);
    }
3660

michaelni's avatar
michaelni committed
3661
    s->mb_width= h->sps.mb_width;
3662
    s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
3663

3664 3665
    h->b_stride=  s->mb_width*4;
    h->b8_stride= s->mb_width*2;
michaelni's avatar
michaelni committed
3666

3667
    s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
michaelni's avatar
michaelni committed
3668
    if(h->sps.frame_mbs_only_flag)
3669
        s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
michaelni's avatar
michaelni committed
3670
    else
3671
        s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 3);
3672 3673

    if (s->context_initialized
michael's avatar
michael committed
3674
        && (   s->width != s->avctx->width || s->height != s->avctx->height)) {
3675 3676
        if(h != h0)
            return -1;   // width / height changed during parallelized decoding
michaelni's avatar
michaelni committed
3677
        free_tables(h);
3678
        flush_dpb(s->avctx);
michaelni's avatar
michaelni committed
3679 3680 3681
        MPV_common_end(s);
    }
    if (!s->context_initialized) {
3682 3683
        if(h != h0)
            return -1;  // we cant (re-)initialize context during parallel decoding
michaelni's avatar
michaelni committed
3684 3685
        if (MPV_common_init(s) < 0)
            return -1;
3686
        s->first_field = 0;
3687

3688
        init_scan_tables(h);
michaelni's avatar
michaelni committed
3689 3690
        alloc_tables(h);

3691 3692 3693
        for(i = 1; i < s->avctx->thread_count; i++) {
            H264Context *c;
            c = h->thread_context[i] = av_malloc(sizeof(H264Context));
3694
            memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
            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
3706 3707
        s->avctx->width = s->width;
        s->avctx->height = s->height;
michael's avatar
michael committed
3708
        s->avctx->sample_aspect_ratio= h->sps.sar;
michael's avatar
michael committed
3709 3710
        if(!s->avctx->sample_aspect_ratio.den)
            s->avctx->sample_aspect_ratio.den = 1;
3711

michael's avatar
michael committed
3712
        if(h->sps.timing_info_present_flag){
3713
            s->avctx->time_base= (AVRational){h->sps.num_units_in_tick * 2, h->sps.time_scale};
3714 3715 3716 3717
            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);
3718
        }
michaelni's avatar
michaelni committed
3719 3720 3721 3722
    }

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

lorenm's avatar
lorenm committed
3723
    h->mb_mbaff = 0;
3724
    h->mb_aff_frame = 0;
3725
    last_pic_structure = s0->picture_structure;
michaelni's avatar
michaelni committed
3726 3727 3728
    if(h->sps.frame_mbs_only_flag){
        s->picture_structure= PICT_FRAME;
    }else{
3729
        if(get_bits1(&s->gb)) { //field_pic_flag
michaelni's avatar
michaelni committed
3730
            s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
3731
        } else {
michaelni's avatar
michaelni committed
3732
            s->picture_structure= PICT_FRAME;
3733
            h->mb_aff_frame = h->sps.mb_aff;
3734
        }
michaelni's avatar
michaelni committed
3735
    }
3736
    h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
3737 3738

    if(h0->current_slice == 0){
michael's avatar
michael committed
3739 3740 3741 3742 3743 3744 3745 3746 3747 3748
        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);
        }

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 3783 3784 3785 3786 3787 3788 3789 3790
        /* 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;
3791
            return -1;
3792
        }
3793 3794 3795 3796 3797 3798
    }
    if(h != h0)
        clone_slice(h, h0);

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

3799
    assert(s->mb_num == s->mb_width * s->mb_height);
3800
    if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
3801 3802
       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
3803 3804
        return -1;
    }
3805
    s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
3806 3807 3808
    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;
3809
    assert(s->mb_y < s->mb_height);
3810

michaelni's avatar
michaelni committed
3811 3812 3813 3814
    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{
3815
        h->curr_pic_num= 2*h->frame_num + 1;
michaelni's avatar
michaelni committed
3816 3817
        h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
    }
3818

michaelni's avatar
michaelni committed
3819
    if(h->nal_unit_type == NAL_IDR_SLICE){
bellard's avatar
bellard committed
3820
        get_ue_golomb(&s->gb); /* idr_pic_id */
michaelni's avatar
michaelni committed
3821
    }
3822

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

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

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

michaelni's avatar
michaelni committed
3834 3835 3836
        if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
            h->delta_poc[1]= get_se_golomb(&s->gb);
    }
3837

michaelni's avatar
michaelni committed
3838
    init_poc(h);
3839

michaelni's avatar
michaelni committed
3840 3841 3842 3843
    if(h->pps.redundant_pic_cnt_present){
        h->redundant_pic_count= get_ue_golomb(&s->gb);
    }

diego's avatar
diego committed
3844
    //set defaults, might be overridden a few lines later
michaelni's avatar
michaelni committed
3845 3846 3847
    h->ref_count[0]= h->pps.ref_count[0];
    h->ref_count[1]= h->pps.ref_count[1];

michael's avatar
michael committed
3848
    if(h->slice_type_nos != FF_I_TYPE){
3849
        if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
3850 3851 3852
            h->direct_spatial_mv_pred= get_bits1(&s->gb);
        }
        num_ref_idx_active_override_flag= get_bits1(&s->gb);
3853

michaelni's avatar
michaelni committed
3854 3855
        if(num_ref_idx_active_override_flag){
            h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
3856
            if(h->slice_type_nos==FF_B_TYPE)
michaelni's avatar
michaelni committed
3857 3858
                h->ref_count[1]= get_ue_golomb(&s->gb) + 1;

michael's avatar
michael committed
3859
            if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
3860
                av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
3861
                h->ref_count[0]= h->ref_count[1]= 1;
michaelni's avatar
michaelni committed
3862 3863 3864
                return -1;
            }
        }
3865
        if(h->slice_type_nos == FF_B_TYPE)
michael's avatar
michael committed
3866 3867 3868 3869 3870
            h->list_count= 2;
        else
            h->list_count= 1;
    }else
        h->list_count= 0;
michaelni's avatar
michaelni committed
3871

3872
    if(!default_ref_list_done){
michaelni's avatar
michaelni committed
3873 3874 3875
        fill_default_ref_list(h);
    }

3876
    if(h->slice_type_nos!=FF_I_TYPE && decode_ref_pic_list_reordering(h) < 0)
3877
        return -1;
michaelni's avatar
michaelni committed
3878

3879 3880
    if(h->slice_type_nos!=FF_I_TYPE){
        s->last_picture_ptr= &h->ref_list[0][0];
3881
        ff_copy_picture(&s->last_picture, s->last_picture_ptr);
3882 3883 3884
    }
    if(h->slice_type_nos==FF_B_TYPE){
        s->next_picture_ptr= &h->ref_list[1][0];
3885
        ff_copy_picture(&s->next_picture, s->next_picture_ptr);
3886 3887
    }

michael's avatar
michael committed
3888
    if(   (h->pps.weighted_pred          && h->slice_type_nos == FF_P_TYPE )
3889
       ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) )
michaelni's avatar
michaelni committed
3890
        pred_weight_table(h);
3891
    else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE)
lorenm's avatar
lorenm committed
3892 3893 3894
        implicit_weight_table(h);
    else
        h->use_weight = 0;
3895

3896
    if(h->nal_ref_idc)
3897
        decode_ref_pic_marking(h0, &s->gb);
michaelni's avatar
michaelni committed
3898

lorenm's avatar
lorenm committed
3899 3900 3901
    if(FRAME_MBAFF)
        fill_mbaff_ref_list(h);

3902 3903 3904 3905
    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
3906
    if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){
3907 3908 3909 3910 3911 3912 3913
        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;
    }
3914 3915

    h->last_qscale_diff = 0;
3916 3917 3918
    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
3919 3920
        return -1;
    }
3921
    s->qscale= tmp;
3922 3923
    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
3924
    //FIXME qscale / qp ... stuff
3925
    if(h->slice_type == FF_SP_TYPE){
bellard's avatar
bellard committed
3926
        get_bits1(&s->gb); /* sp_for_switch_flag */
michaelni's avatar
michaelni committed
3927
    }
3928
    if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){
bellard's avatar
bellard committed
3929
        get_se_golomb(&s->gb); /* slice_qs_delta */
michaelni's avatar
michaelni committed
3930 3931
    }

3932
    h->deblocking_filter = 1;
michael's avatar
michael committed
3933 3934
    h->slice_alpha_c0_offset = 0;
    h->slice_beta_offset = 0;
michaelni's avatar
michaelni committed
3935
    if( h->pps.deblocking_filter_parameters_present ) {
3936 3937 3938 3939 3940 3941
        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;
3942
        if(h->deblocking_filter < 2)
3943 3944 3945
            h->deblocking_filter^= 1; // 1<->0

        if( h->deblocking_filter ) {
3946 3947
            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
3948
        }
3949
    }
3950

3951
    if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
3952
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE)
3953
       ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == FF_B_TYPE)
3954 3955 3956
       ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
        h->deblocking_filter= 0;

3957
    if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
3958 3959
        if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
            /* Cheat slightly for speed:
diego's avatar
diego committed
3960
               Do not bother to deblock across slices. */
3961 3962
            h->deblocking_filter = 2;
        } else {
benoit's avatar
benoit committed
3963 3964 3965 3966 3967 3968 3969
            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
3970
        }
3971 3972
    }

michaelni's avatar
michaelni committed
3973 3974 3975 3976 3977
#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

3978 3979
    h0->last_slice_type = slice_type;
    h->slice_num = ++h0->current_slice;
3980 3981 3982
    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
3983

3984
    for(j=0; j<2; j++){
3985
        int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
3986 3987
        ref2frm[0]=
        ref2frm[1]= -1;
3988
        for(i=0; i<16; i++)
3989 3990
            ref2frm[i+2]= 4*h->ref_list[j][i].frame_num
                          +(h->ref_list[j][i].reference&3);
3991 3992 3993 3994 3995
        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);
3996 3997
    }

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

michaelni's avatar
michaelni committed
4001
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4002
        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",
4003 4004
               h->slice_num,
               (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
4005
               first_mb_in_slice,
4006
               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
4007 4008 4009 4010
               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,
4011
               h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
lorenm's avatar
lorenm committed
4012
               h->use_weight,
michael's avatar
michael committed
4013 4014
               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
4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
               );
    }

    return 0;
}

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

michaelni's avatar
michaelni committed
4028 4029 4030
    OPEN_READER(re, gb);
    UPDATE_CACHE(re, gb);
    buf=GET_CACHE(re, gb);
4031

michaelni's avatar
michaelni committed
4032 4033 4034
    log= 32 - av_log2(buf);
#ifdef TRACE
    print_bin(buf>>(32-log), log);
4035
    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
4036 4037 4038 4039 4040 4041 4042 4043
#endif

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

    return log-1;
}

lorenm's avatar
lorenm committed
4044
static inline int get_dct8x8_allowed(H264Context *h){
michael's avatar
michael committed
4045 4046 4047 4048
    if(h->sps.direct_8x8_inference_flag)
        return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8                )*0x0001000100010001ULL));
    else
        return !(*(uint64_t*)h->sub_mb_type & ((MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_8x8|MB_TYPE_DIRECT2)*0x0001000100010001ULL));
lorenm's avatar
lorenm committed
4049 4050
}

michaelni's avatar
michaelni committed
4051 4052 4053 4054 4055
/**
 * 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
4056
 * @return <0 if an error occurred
michaelni's avatar
michaelni committed
4057
 */
lorenm's avatar
lorenm committed
4058
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
4059 4060
    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
4061 4062
    int level[16];
    int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
michaelni's avatar
michaelni committed
4063 4064 4065 4066 4067 4068

    //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;
4069
    }else{
michaelni's avatar
michaelni committed
4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085
        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;
4086 4087
    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);
4088 4089
        return -1;
    }
4090

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

4095 4096 4097 4098 4099
    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
4100

4101
    if(trailing_ones<total_coeff) {
michaelni's avatar
michaelni committed
4102
        int level_code, mask;
lorenm's avatar
lorenm committed
4103 4104
        int suffix_length = total_coeff > 10 && trailing_ones < 3;
        int prefix= get_level_prefix(gb);
michaelni's avatar
michaelni committed
4105

lorenm's avatar
lorenm committed
4106
        //first coefficient has suffix_length equal to 0 or 1
michaelni's avatar
michaelni committed
4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117
        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
4118 4119 4120 4121
            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
4122 4123
        }

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

lorenm's avatar
lorenm committed
4126 4127 4128
        suffix_length = 1;
        if(level_code > 5)
            suffix_length++;
michaelni's avatar
michaelni committed
4129
        mask= -(level_code&1);
4130
        level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
lorenm's avatar
lorenm committed
4131 4132

        //remaining coefficients have suffix_length > 0
4133
        for(i=trailing_ones+1;i<total_coeff;i++) {
lorenm's avatar
lorenm committed
4134 4135 4136 4137 4138
            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
4139 4140 4141
                level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
                if(prefix>=16)
                    level_code += (1<<(prefix-3))-4096;
lorenm's avatar
lorenm committed
4142 4143 4144 4145 4146 4147
            }
            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
4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
    }

    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
4159 4160
    coeff_num = zeros_left + total_coeff - 1;
    j = scantable[coeff_num];
michaelni's avatar
michaelni committed
4161
    if(n > 24){
lorenm's avatar
lorenm committed
4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172
        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
4173 4174 4175 4176 4177
            j= scantable[ coeff_num ];

            block[j]= level[i];
        }
    }else{
lorenm's avatar
lorenm committed
4178
        block[j] = (level[0] * qmul[j] + 32)>>6;
lorenm's avatar
lorenm committed
4179 4180 4181 4182 4183 4184 4185 4186 4187 4188
        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
4189 4190
            j= scantable[ coeff_num ];

lorenm's avatar
lorenm committed
4191
            block[j]= (level[i] * qmul[j] + 32)>>6;
michaelni's avatar
michaelni committed
4192 4193
        }
    }
lorenm's avatar
lorenm committed
4194 4195 4196 4197 4198 4199

    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
4200 4201 4202
    return 0;
}

lorenm's avatar
lorenm committed
4203 4204
static void predict_field_decoding_flag(H264Context *h){
    MpegEncContext * const s = &h->s;
4205
    const int mb_xy= h->mb_xy;
lorenm's avatar
lorenm committed
4206 4207 4208 4209 4210 4211 4212 4213
    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;
}

4214 4215 4216 4217 4218
/**
 * decodes a P_SKIP or B_SKIP macroblock
 */
static void decode_mb_skip(H264Context *h){
    MpegEncContext * const s = &h->s;
4219
    const int mb_xy= h->mb_xy;
4220
    int mb_type=0;
4221

4222 4223 4224
    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
4225
    if(MB_FIELD)
4226
        mb_type|= MB_TYPE_INTERLACED;
4227

4228
    if( h->slice_type_nos == FF_B_TYPE )
4229 4230
    {
        // just for fill_caches. pred_direct_motion will set the real mb_type
4231
        mb_type|= MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
4232

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

michael's avatar
michael committed
4242
        fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
4243 4244 4245 4246 4247 4248
        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);
4249
    s->current_picture.mb_type[mb_xy]= mb_type;
4250 4251
    s->current_picture.qscale_table[mb_xy]= s->qscale;
    h->slice_table[ mb_xy ]= h->slice_num;
4252
    h->prev_mb_skipped= 1;
4253 4254
}

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

4266 4267
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;

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

michaelni's avatar
michaelni committed
4275
        if (s->mb_skip_run--) {
lorenm's avatar
lorenm committed
4276 4277 4278 4279 4280 4281
            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);
            }
4282
            decode_mb_skip(h);
michaelni's avatar
michaelni committed
4283 4284 4285
            return 0;
        }
    }
lorenm's avatar
lorenm committed
4286 4287 4288
    if(FRAME_MBAFF){
        if( (s->mb_y&1) == 0 )
            h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
4289
    }
4290

4291
    h->prev_mb_skipped= 0;
4292

michaelni's avatar
michaelni committed
4293
    mb_type= get_ue_golomb(&s->gb);
4294
    if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
4295 4296 4297 4298 4299 4300 4301
        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;
        }
4302
    }else if(h->slice_type_nos == FF_P_TYPE){
michaelni's avatar
michaelni committed
4303 4304 4305 4306 4307 4308 4309 4310
        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{
4311 4312 4313
       assert(h->slice_type_nos == FF_I_TYPE);
        if(h->slice_type == FF_SI_TYPE && mb_type)
            mb_type--;
michaelni's avatar
michaelni committed
4314 4315
decode_intra_mb:
        if(mb_type > 25){
diego's avatar
diego committed
4316
            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
4317 4318 4319 4320 4321 4322 4323 4324
            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
4325
    if(MB_FIELD)
michaelni's avatar
michaelni committed
4326 4327 4328
        mb_type |= MB_TYPE_INTERLACED;

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

michaelni's avatar
michaelni committed
4330
    if(IS_INTRA_PCM(mb_type)){
michael's avatar
michael committed
4331
        unsigned int x;
4332

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

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

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

lorenm's avatar
lorenm committed
4346
        s->current_picture.mb_type[mb_xy]= mb_type;
michaelni's avatar
michaelni committed
4347 4348
        return 0;
    }
4349

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

michael's avatar
michael committed
4355
    fill_caches(h, mb_type, 0);
michaelni's avatar
michaelni committed
4356 4357 4358

    //mb_pred
    if(IS_INTRA(mb_type)){
michael's avatar
michael committed
4359
        int pred_mode;
michaelni's avatar
michaelni committed
4360
//            init_top_left_availability(h);
michael's avatar
michael committed
4361 4362 4363 4364 4365 4366 4367
        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
4368 4369

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

michael's avatar
michael committed
4373 4374 4375
                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
4376
                }
michael's avatar
michael committed
4377 4378 4379 4380 4381

                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
4382
            }
michael's avatar
michael committed
4383 4384 4385 4386 4387 4388 4389 4390 4391
            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){
4392 4393
            pred_mode= check_intra_pred_mode(h, get_ue_golomb(&s->gb));
            if(pred_mode < 0)
michaelni's avatar
michaelni committed
4394
                return -1;
4395
            h->chroma_pred_mode= pred_mode;
michael's avatar
michael committed
4396
        }
michaelni's avatar
michaelni committed
4397 4398
    }else if(partition_count==4){
        int i, j, sub_partition_count[4], list, ref[2][4];
4399

4400
        if(h->slice_type_nos == FF_B_TYPE){
michaelni's avatar
michaelni committed
4401 4402 4403
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb(&s->gb);
                if(h->sub_mb_type[i] >=13){
4404
                    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
4405 4406 4407 4408 4409
                    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;
            }
4410
            if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
4411
               || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
4412
                pred_direct_motion(h, &mb_type);
4413 4414 4415 4416 4417
                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
4418
        }else{
michael's avatar
michael committed
4419
            assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
michaelni's avatar
michaelni committed
4420 4421 4422
            for(i=0; i<4; i++){
                h->sub_mb_type[i]= get_ue_golomb(&s->gb);
                if(h->sub_mb_type[i] >=4){
4423
                    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
4424 4425 4426 4427 4428 4429
                    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;
            }
        }
4430

4431
        for(list=0; list<h->list_count; list++){
4432
            int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
michaelni's avatar
michaelni committed
4433
            for(i=0; i<4; i++){
4434 4435
                if(IS_DIRECT(h->sub_mb_type[i])) continue;
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
4436 4437 4438 4439 4440 4441
                    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
4442 4443 4444 4445 4446 4447
                }else{
                 //FIXME
                    ref[list][i] = -1;
                }
            }
        }
4448

lorenm's avatar
lorenm committed
4449 4450
        if(dct8x8_allowed)
            dct8x8_allowed = get_dct8x8_allowed(h);
4451

4452
        for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4453
            for(i=0; i<4; i++){
4454 4455 4456 4457
                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
4458 4459 4460
                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];

4461
                if(IS_DIR(h->sub_mb_type[i], 0, list)){
michaelni's avatar
michaelni committed
4462 4463 4464 4465 4466 4467 4468 4469 4470
                    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
4471
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4472

michaelni's avatar
michaelni committed
4473
                        if(IS_SUB_8X8(sub_mb_type)){
4474
                            mv_cache[ 1 ][0]=
michaelni's avatar
michaelni committed
4475
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
4476
                            mv_cache[ 1 ][1]=
michaelni's avatar
michaelni committed
4477 4478
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
                        }else if(IS_SUB_8X4(sub_mb_type)){
4479 4480
                            mv_cache[ 1 ][0]= mx;
                            mv_cache[ 1 ][1]= my;
michaelni's avatar
michaelni committed
4481
                        }else if(IS_SUB_4X8(sub_mb_type)){
4482 4483
                            mv_cache[ 8 ][0]= mx;
                            mv_cache[ 8 ][1]= my;
michaelni's avatar
michaelni committed
4484
                        }
4485 4486
                        mv_cache[ 0 ][0]= mx;
                        mv_cache[ 0 ][1]= my;
michaelni's avatar
michaelni committed
4487 4488 4489 4490 4491 4492 4493 4494
                    }
                }else{
                    uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
                    p[0] = p[1]=
                    p[8] = p[9]= 0;
                }
            }
        }
4495 4496
    }else if(IS_DIRECT(mb_type)){
        pred_direct_motion(h, &mb_type);
lorenm's avatar
lorenm committed
4497
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
4498
    }else{
michaelni's avatar
michaelni committed
4499 4500 4501
        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
4502 4503
            for(list=0; list<h->list_count; list++){
                    unsigned int val;
michaelni's avatar
michaelni committed
4504
                    if(IS_DIR(mb_type, 0, list)){
michael's avatar
michael committed
4505
                        val= get_te0_golomb(&s->gb, h->ref_count[list]);
4506 4507 4508 4509
                        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
4510
                    }else
michael's avatar
michael committed
4511 4512
                        val= LIST_NOT_USED&0xFF;
                    fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
michaelni's avatar
michaelni committed
4513
            }
michael's avatar
michael committed
4514 4515
            for(list=0; list<h->list_count; list++){
                unsigned int val;
michaelni's avatar
michaelni committed
4516 4517 4518 4519
                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
4520
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4521

michael's avatar
michael committed
4522
                    val= pack16to32(mx,my);
lorenm's avatar
lorenm committed
4523
                }else
michael's avatar
michael committed
4524 4525
                    val=0;
                fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, val, 4);
michaelni's avatar
michaelni committed
4526 4527 4528
            }
        }
        else if(IS_16X8(mb_type)){
michael's avatar
michael committed
4529
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4530
                    for(i=0; i<2; i++){
michael's avatar
michael committed
4531
                        unsigned int val;
michaelni's avatar
michaelni committed
4532
                        if(IS_DIR(mb_type, i, list)){
michael's avatar
michael committed
4533
                            val= get_te0_golomb(&s->gb, h->ref_count[list]);
4534 4535 4536 4537
                            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
4538
                        }else
michael's avatar
michael committed
4539 4540
                            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
4541 4542
                    }
            }
michael's avatar
michael committed
4543
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4544
                for(i=0; i<2; i++){
michael's avatar
michael committed
4545
                    unsigned int val;
michaelni's avatar
michaelni committed
4546 4547 4548 4549
                    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
4550
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4551

michael's avatar
michael committed
4552
                        val= pack16to32(mx,my);
4553
                    }else
michael's avatar
michael committed
4554 4555
                        val=0;
                    fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
michaelni's avatar
michaelni committed
4556 4557 4558 4559
                }
            }
        }else{
            assert(IS_8X16(mb_type));
michael's avatar
michael committed
4560
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4561
                    for(i=0; i<2; i++){
michael's avatar
michael committed
4562
                        unsigned int val;
michaelni's avatar
michaelni committed
4563
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
michael's avatar
michael committed
4564
                            val= get_te0_golomb(&s->gb, h->ref_count[list]);
4565 4566 4567 4568
                            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
4569
                        }else
michael's avatar
michael committed
4570 4571
                            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
4572 4573
                    }
            }
michael's avatar
michael committed
4574
            for(list=0; list<h->list_count; list++){
michaelni's avatar
michaelni committed
4575
                for(i=0; i<2; i++){
michael's avatar
michael committed
4576
                    unsigned int val;
michaelni's avatar
michaelni committed
4577 4578 4579 4580
                    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
4581
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
4582

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

michaelni's avatar
michaelni committed
4592 4593
    if(IS_INTER(mb_type))
        write_back_motion(h, mb_type);
4594

michaelni's avatar
michaelni committed
4595 4596 4597
    if(!IS_INTRA16x16(mb_type)){
        cbp= get_ue_golomb(&s->gb);
        if(cbp > 47){
4598
            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
4599 4600
            return -1;
        }
4601

4602
        if(CHROMA){
michael's avatar
michael committed
4603 4604
            if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
            else                     cbp= golomb_to_inter_cbp   [cbp];
4605 4606 4607 4608
        }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
4609
    }
lorenm's avatar
lorenm committed
4610
    h->cbp = cbp;
michaelni's avatar
michaelni committed
4611

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

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

michaelni's avatar
michaelni committed
4626 4627 4628
//        fill_non_zero_count_cache(h);

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

        dquant= get_se_golomb(&s->gb);

        if( dquant > 25 || dquant < -26 ){
4641
            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
4642 4643
            return -1;
        }
4644

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

4651 4652
        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
4653
        if(IS_INTRA16x16(mb_type)){
lorenm's avatar
lorenm committed
4654
            if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
4655
                return -1; //FIXME continue if partitioned and other return -1 too
michaelni's avatar
michaelni committed
4656 4657 4658 4659 4660 4661 4662 4663
            }

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

lorenm's avatar
lorenm committed
4689
                            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
4690 4691
                                return -1;
                            }
michaelni's avatar
michaelni committed
4692 4693 4694 4695 4696 4697 4698 4699
                        }
                    }
                }else{
                    uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
                    nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
                }
            }
        }
4700

michaelni's avatar
michaelni committed
4701 4702
        if(cbp&0x30){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++)
lorenm's avatar
lorenm committed
4703
                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
4704 4705 4706 4707 4708 4709
                    return -1;
                }
        }

        if(cbp&0x20){
            for(chroma_idx=0; chroma_idx<2; chroma_idx++){
4710
                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
4711 4712
                for(i4x4=0; i4x4<4; i4x4++){
                    const int index= 16 + 4*chroma_idx + i4x4;
4713
                    if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
michaelni's avatar
michaelni committed
4714 4715 4716 4717 4718 4719 4720 4721 4722 4723
                        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{
4724 4725 4726 4727
        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
4728
    }
4729
    s->current_picture.qscale_table[mb_xy]= s->qscale;
michaelni's avatar
michaelni committed
4730 4731
    write_back_non_zero_count(h);

lorenm's avatar
lorenm committed
4732 4733 4734 4735 4736
    if(MB_MBAFF){
        h->ref_count[0] >>= 1;
        h->ref_count[1] >>= 1;
    }

michaelni's avatar
michaelni committed
4737 4738 4739
    return 0;
}

4740 4741 4742 4743 4744 4745 4746 4747
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;
4748

4749 4750 4751 4752 4753 4754 4755
    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;
    }

4756
    return get_cabac_noinline( &h->cabac, &h->cabac_state[70 + ctx] );
4757 4758
}

michael's avatar
michael committed
4759 4760 4761
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;
4762

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

michael's avatar
michael committed
4780 4781
    if( get_cabac_terminate( &h->cabac ) )
        return 25;  /* PCM */
4782

michael's avatar
michael committed
4783
    mb_type = 1; /* I16x16 */
4784 4785 4786 4787 4788
    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
4789 4790
    return mb_type;
}
4791

michael's avatar
michael committed
4792 4793 4794
static int decode_cabac_mb_type( H264Context *h ) {
    MpegEncContext * const s = &h->s;

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

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

4822
        if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) )
4823 4824
            return 0; /* B_Direct_16x16 */

4825 4826
        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 */
4827 4828
        }

4829 4830 4831 4832
        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] );
4833 4834 4835
        if( bits < 8 )
            return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
        else if( bits == 13 ) {
michael's avatar
michael committed
4836
            return decode_cabac_intra_mb_type(h, 32, 0) + 23;
4837 4838 4839 4840 4841
        } else if( bits == 14 )
            return 11; /* B_L1_L0_8x16 */
        else if( bits == 15 )
            return 22; /* B_8x8 */

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

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

lorenm's avatar
lorenm committed
4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867
    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{
4868
        int mb_xy = h->mb_xy;
lorenm's avatar
lorenm committed
4869
        mba_xy = mb_xy - 1;
4870
        mbb_xy = mb_xy - (s->mb_stride << FIELD_PICTURE);
lorenm's avatar
lorenm committed
4871 4872
    }

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

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

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
4889 4890 4891 4892
    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] );

4893 4894 4895 4896 4897 4898 4899
    if( mode >= pred_mode )
        return mode + 1;
    else
        return mode;
}

static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
4900 4901
    const int mba_xy = h->left_mb_xy[0];
    const int mbb_xy = h->top_mb_xy;
4902 4903 4904

    int ctx = 0;

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

4909
    if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
4910 4911
        ctx++;

4912
    if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
4913 4914
        return 0;

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

static int decode_cabac_mb_cbp_luma( H264Context *h) {
4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
    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;
4937 4938 4939 4940 4941 4942
    return cbp;
}
static int decode_cabac_mb_cbp_chroma( H264Context *h) {
    int ctx;
    int cbp_a, cbp_b;

michael's avatar
michael committed
4943 4944
    cbp_a = (h->left_cbp>>4)&0x03;
    cbp_b = (h-> top_cbp>>4)&0x03;
4945 4946 4947 4948

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

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

4961
    while( get_cabac_noinline( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
4962
        ctx= 2+(ctx>>1);
4963
        val++;
lorenm's avatar
lorenm committed
4964
        if(val > 102) //prevent infinite loop
4965
            return INT_MIN;
4966 4967 4968
    }

    if( val&0x01 )
4969
        return   (val + 1)>>1 ;
4970
    else
4971
        return -((val + 1)>>1);
4972
}
4973
static int decode_cabac_p_mb_sub_type( H264Context *h ) {
4974 4975 4976 4977 4978 4979 4980 4981
    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 */
}
4982 4983 4984 4985 4986
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] ) )
4987
        return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
4988 4989 4990 4991 4992 4993 4994 4995 4996 4997
    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;
}
4998

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

5003 5004 5005 5006 5007 5008
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;

5009
    if( h->slice_type_nos == FF_B_TYPE) {
5010 5011 5012 5013 5014 5015 5016 5017 5018 5019
        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;
    }
5020 5021 5022 5023 5024 5025 5026

    while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
        ref++;
        if( ctx < 4 )
            ctx = 4;
        else
            ctx = 5;
5027
        if(ref >= 32 /*h->ref_list[list]*/){
5028
            return -1;
5029
        }
5030 5031 5032 5033 5034 5035 5036 5037
    }
    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;
5038 5039
    int mvd;
    int ctx = (amvd>2) + (amvd>32);
5040

michael's avatar
michael committed
5041 5042 5043 5044 5045
    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
        return 0;

    mvd= 1;
    ctx= 3;
5046 5047
    while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
        mvd++;
michael's avatar
michael committed
5048
        if( ctx < 6 )
5049 5050 5051 5052 5053 5054 5055 5056
            ctx++;
    }

    if( mvd >= 9 ) {
        int k = 3;
        while( get_cabac_bypass( &h->cabac ) ) {
            mvd += 1 << k;
            k++;
5057 5058 5059 5060
            if(k>24){
                av_log(h->s.avctx, AV_LOG_ERROR, "overflow in decode_cabac_mb_mvd\n");
                return INT_MIN;
            }
5061 5062 5063 5064 5065 5066
        }
        while( k-- ) {
            if( get_cabac_bypass( &h->cabac ) )
                mvd += 1 << k;
        }
    }
5067
    return get_cabac_bypass_sign( &h->cabac, -mvd );
5068 5069
}

5070
static av_always_inline int get_cabac_cbf_ctx( H264Context *h, int cat, int idx, int is_dc ) {
michael's avatar
michael committed
5071
    int nza, nzb;
5072 5073
    int ctx = 0;

5074
    if( is_dc ) {
astrange's avatar
astrange committed
5075 5076 5077 5078 5079 5080 5081
        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
5082
    } else {
5083 5084 5085
        assert(cat == 1 || cat == 2 || cat == 4);
        nza = h->non_zero_count_cache[scan8[idx] - 1];
        nzb = h->non_zero_count_cache[scan8[idx] - 8];
5086
    }
5087

michael's avatar
michael committed
5088
    if( nza > 0 )
5089 5090
        ctx++;

michael's avatar
michael committed
5091
    if( nzb > 0 )
5092 5093 5094 5095 5096
        ctx += 2;

    return ctx + 4 * cat;
}

5097
DECLARE_ASM_CONST(1, uint8_t, last_coeff_flag_offset_8x8[63]) = {
michael's avatar
michael committed
5098 5099 5100 5101 5102 5103
    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
};

5104
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
5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115
    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
5116
    static const uint8_t significant_coeff_flag_offset_8x8[2][63] = {
lorenm's avatar
lorenm committed
5117
      { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
lorenm's avatar
lorenm committed
5118 5119
        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
5120 5121 5122 5123 5124
       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
5125
    };
5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137
    /* 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
5138 5139

    int index[64];
5140

benoit's avatar
benoit committed
5141
    int av_unused last;
5142
    int coeff_count = 0;
5143
    int node_ctx = 0;
5144

lorenm's avatar
lorenm committed
5145 5146 5147
    uint8_t *significant_coeff_ctx_base;
    uint8_t *last_coeff_ctx_base;
    uint8_t *abs_level_m1_ctx_base;
lorenm's avatar
lorenm committed
5148

5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162
#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


5163 5164 5165 5166
    /* cat: 0-> DC 16x16  n = 0
     *      1-> AC 16x16  n = luma4x4idx
     *      2-> Luma4x4   n = luma4x4idx
     *      3-> DC Chroma n = iCbCr
5167
     *      4-> AC Chroma n = 16 + 4 * iCbCr + chroma4x4idx
lorenm's avatar
lorenm committed
5168
     *      5-> Luma8x8   n = 4 * luma8x8idx
5169 5170 5171
     */

    /* read coded block flag */
5172 5173
    if( is_dc || cat != 5 ) {
        if( get_cabac( CC, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n, is_dc ) ] ) == 0 ) {
5174 5175
            if( !is_dc )
                h->non_zero_count_cache[scan8[n]] = 0;
5176

5177 5178 5179 5180 5181
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
5182
            return;
lorenm's avatar
lorenm committed
5183
        }
5184 5185
    }

lorenm's avatar
lorenm committed
5186
    significant_coeff_ctx_base = h->cabac_state
lorenm's avatar
lorenm committed
5187
        + significant_coeff_flag_offset[MB_FIELD][cat];
lorenm's avatar
lorenm committed
5188
    last_coeff_ctx_base = h->cabac_state
lorenm's avatar
lorenm committed
5189
        + last_coeff_flag_offset[MB_FIELD][cat];
lorenm's avatar
lorenm committed
5190 5191 5192
    abs_level_m1_ctx_base = h->cabac_state
        + coeff_abs_level_m1_offset[cat];

5193
    if( !is_dc && cat == 5 ) {
lorenm's avatar
lorenm committed
5194 5195 5196
#define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
        for(last= 0; last < coefs; last++) { \
            uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
5197
            if( get_cabac( CC, sig_ctx )) { \
lorenm's avatar
lorenm committed
5198 5199
                uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
                index[coeff_count++] = last; \
5200
                if( get_cabac( CC, last_ctx ) ) { \
lorenm's avatar
lorenm committed
5201 5202 5203 5204
                    last= max_coeff; \
                    break; \
                } \
            } \
5205 5206 5207
        }\
        if( last == max_coeff -1 ) {\
            index[coeff_count++] = last;\
lorenm's avatar
lorenm committed
5208
        }
michael's avatar
michael committed
5209
        const uint8_t *sig_off = significant_coeff_flag_offset_8x8[MB_FIELD];
ramiro's avatar
ramiro committed
5210
#if defined(ARCH_X86) && defined(HAVE_7REGS) && defined(HAVE_EBX_AVAILABLE) && !defined(BROKEN_RELOCATIONS)
michael's avatar
michael committed
5211 5212
        coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index, sig_off);
    } else {
5213
        coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index);
5214
#else
michael's avatar
michael committed
5215 5216
        DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
    } else {
lorenm's avatar
lorenm committed
5217
        DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
5218
#endif
5219
    }
michael's avatar
michael committed
5220
    assert(coeff_count > 0);
5221

5222
    if( is_dc ) {
astrange's avatar
astrange committed
5223 5224 5225 5226
        if( cat == 0 )
            h->cbp_table[h->mb_xy] |= 0x100;
        else
            h->cbp_table[h->mb_xy] |= 0x40 << n;
5227
    } else {
5228 5229
        if( cat == 5 )
            fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
astrange's avatar
astrange committed
5230
        else {
5231
            assert( cat == 1 || cat == 2 || cat == 4 );
5232
            h->non_zero_count_cache[scan8[n]] = coeff_count;
astrange's avatar
astrange committed
5233
        }
5234
    }
5235

5236
    do {
5237 5238
        uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base;

5239
        int j= scantable[index[--coeff_count]];
5240

5241
        if( get_cabac( CC, ctx ) == 0 ) {
5242
            node_ctx = coeff_abs_level_transition[0][node_ctx];
5243
            if( is_dc ) {
5244
                block[j] = get_cabac_bypass_sign( CC, -1);
michael's avatar
michael committed
5245
            }else{
michael's avatar
michael committed
5246
                block[j] = (get_cabac_bypass_sign( CC, -qmul[j]) + 32) >> 6;
michael's avatar
michael committed
5247
            }
5248
        } else {
michael's avatar
michael committed
5249
            int coeff_abs = 2;
5250 5251 5252
            ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base;
            node_ctx = coeff_abs_level_transition[1][node_ctx];

5253
            while( coeff_abs < 15 && get_cabac( CC, ctx ) ) {
michael's avatar
michael committed
5254
                coeff_abs++;
5255 5256
            }

michael's avatar
michael committed
5257 5258
            if( coeff_abs >= 15 ) {
                int j = 0;
5259
                while( get_cabac_bypass( CC ) ) {
michael's avatar
michael committed
5260 5261
                    j++;
                }
5262

michael's avatar
michael committed
5263
                coeff_abs=1;
michael's avatar
michael committed
5264
                while( j-- ) {
5265
                    coeff_abs += coeff_abs + get_cabac_bypass( CC );
michael's avatar
michael committed
5266
                }
michael's avatar
michael committed
5267
                coeff_abs+= 14;
5268 5269
            }

5270
            if( is_dc ) {
5271
                block[j] = get_cabac_bypass_sign( CC, -coeff_abs );
michael's avatar
michael committed
5272
            }else{
5273
                block[j] = (get_cabac_bypass_sign( CC, -coeff_abs ) * qmul[j] + 32) >> 6;
michael's avatar
michael committed
5274
            }
michael's avatar
michael committed
5275
        }
5276
    } while( coeff_count );
5277 5278 5279 5280 5281
#ifdef CABAC_ON_STACK
            h->cabac.range     = cc.range     ;
            h->cabac.low       = cc.low       ;
            h->cabac.bytestream= cc.bytestream;
#endif
5282

5283 5284
}

5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303
#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
}

5304
static inline void compute_mb_neighbors(H264Context *h)
5305 5306
{
    MpegEncContext * const s = &h->s;
5307
    const int mb_xy  = h->mb_xy;
5308 5309
    h->top_mb_xy     = mb_xy - s->mb_stride;
    h->left_mb_xy[0] = mb_xy - 1;
lorenm's avatar
lorenm committed
5310
    if(FRAME_MBAFF){
5311 5312 5313 5314
        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
5315
        const int curr_mb_frame_flag = !MB_FIELD;
5316 5317 5318 5319 5320 5321 5322 5323 5324 5325
        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;
        }
5326 5327
    } else if (FIELD_PICTURE) {
        h->top_mb_xy -= s->mb_stride;
5328 5329 5330 5331
    }
    return;
}

5332 5333
/**
 * decodes a macroblock
diego's avatar
diego committed
5334
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
5335 5336 5337
 */
static int decode_mb_cabac(H264Context *h) {
    MpegEncContext * const s = &h->s;
5338
    int mb_xy;
5339
    int mb_type, partition_count, cbp = 0;
lorenm's avatar
lorenm committed
5340
    int dct8x8_allowed= h->pps.transform_8x8_mode;
5341

5342 5343
    mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;

mbardiaux's avatar
mbardiaux committed
5344
    tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
michael's avatar
michael committed
5345
    if( h->slice_type_nos != FF_I_TYPE ) {
lorenm's avatar
lorenm committed
5346 5347 5348 5349 5350 5351 5352 5353
        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 );
5354
        /* read skip flags */
lorenm's avatar
lorenm committed
5355 5356 5357 5358
        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 );
michael's avatar
michael committed
5359
                if(!h->next_mb_skipped)
lorenm's avatar
lorenm committed
5360 5361 5362
                    h->mb_mbaff = h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
            }

5363
            decode_mb_skip(h);
5364 5365

            h->cbp_table[mb_xy] = 0;
5366
            h->chroma_pred_mode_table[mb_xy] = 0;
5367 5368 5369 5370 5371 5372
            h->last_qscale_diff = 0;

            return 0;

        }
    }
lorenm's avatar
lorenm committed
5373 5374 5375
    if(FRAME_MBAFF){
        if( (s->mb_y&1) == 0 )
            h->mb_mbaff =
5376
            h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
5377
    }
5378

5379
    h->prev_mb_skipped = 0;
5380

diego's avatar
diego committed
5381
    compute_mb_neighbors(h);
5382 5383
    mb_type = decode_cabac_mb_type( h );
    assert(mb_type >= 0);
5384

5385
    if( h->slice_type_nos == FF_B_TYPE ) {
5386 5387 5388 5389 5390 5391 5392
        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;
        }
5393
    } else if( h->slice_type_nos == FF_P_TYPE ) {
5394 5395 5396 5397 5398 5399 5400 5401
        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 {
5402 5403 5404
        if(h->slice_type == FF_SI_TYPE && mb_type)
            mb_type--;
        assert(h->slice_type_nos == FF_I_TYPE);
5405 5406 5407 5408 5409 5410
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
5411
    if(MB_FIELD)
5412 5413 5414 5415 5416
        mb_type |= MB_TYPE_INTERLACED;

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

    if(IS_INTRA_PCM(mb_type)) {
5417
        const uint8_t *ptr;
5418

diego's avatar
diego committed
5419
        // We assume these blocks are very rare so we do not optimize it.
5420 5421 5422
        // 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;
5423 5424 5425 5426
        if(h->cabac.low&0x1) ptr--;
        if(CABAC_BITS==16){
            if(h->cabac.low&0x1FF) ptr--;
        }
5427 5428

        // The pixels are stored in the same order as levels in h->mb array.
michael's avatar
michael committed
5429
        memcpy(h->mb, ptr, 256); ptr+=256;
5430
        if(CHROMA){
michael's avatar
michael committed
5431
            memcpy(h->mb+128, ptr, 128); ptr+=128;
5432 5433 5434 5435
        }

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

5436
        // All blocks are present
5437
        h->cbp_table[mb_xy] = 0x1ef;
5438
        h->chroma_pred_mode_table[mb_xy] = 0;
5439
        // In deblocking, the quantizer is 0
5440
        s->current_picture.qscale_table[mb_xy]= 0;
5441
        // All coeffs are present
5442
        memset(h->non_zero_count[mb_xy], 16, 16);
lorenm's avatar
lorenm committed
5443
        s->current_picture.mb_type[mb_xy]= mb_type;
5444
        h->last_qscale_diff = 0;
5445
        return 0;
5446 5447
    }

lorenm's avatar
lorenm committed
5448 5449 5450 5451 5452
    if(MB_MBAFF){
        h->ref_count[0] <<= 1;
        h->ref_count[1] <<= 1;
    }

michael's avatar
michael committed
5453
    fill_caches(h, mb_type, 0);
5454 5455

    if( IS_INTRA( mb_type ) ) {
5456
        int i, pred_mode;
5457
        if( IS_INTRA4x4( mb_type ) ) {
lorenm's avatar
lorenm committed
5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468
            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 );
5469 5470

                //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
5471
                }
5472 5473 5474 5475 5476 5477 5478
            }
            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;
        }
5479
        if(CHROMA){
michael's avatar
michael committed
5480 5481
            h->chroma_pred_mode_table[mb_xy] =
            pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
5482

michael's avatar
michael committed
5483 5484 5485
            pred_mode= check_intra_pred_mode( h, pred_mode );
            if( pred_mode < 0 ) return -1;
            h->chroma_pred_mode= pred_mode;
5486
        }
5487
    } else if( partition_count == 4 ) {
5488 5489
        int i, j, sub_partition_count[4], list, ref[2][4];

5490
        if( h->slice_type_nos == FF_B_TYPE ) {
5491 5492 5493 5494 5495
            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
5496 5497
            if( IS_DIRECT(h->sub_mb_type[0] | h->sub_mb_type[1] |
                          h->sub_mb_type[2] | h->sub_mb_type[3]) ) {
5498
                pred_direct_motion(h, &mb_type);
5499 5500 5501 5502
                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;
5503 5504 5505 5506 5507 5508
                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 );
                }
            }
5509 5510 5511 5512 5513 5514
        } 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;
            }
5515 5516
        }

5517
        for( list = 0; list < h->list_count; list++ ) {
5518
                for( i = 0; i < 4; i++ ) {
5519 5520
                    if(IS_DIRECT(h->sub_mb_type[i])) continue;
                    if(IS_DIR(h->sub_mb_type[i], 0, list)){
5521
                        if( h->ref_count[list] > 1 ){
5522
                            ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
5523 5524 5525 5526 5527
                            if(ref[list][i] >= (unsigned)h->ref_count[list]){
                                av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], h->ref_count[list]);
                                return -1;
                            }
                        }else
5528 5529 5530 5531
                            ref[list][i] = 0;
                    } else {
                        ref[list][i] = -1;
                    }
michael's avatar
1000l  
michael committed
5532
                                                       h->ref_cache[list][ scan8[4*i]+1 ]=
5533 5534 5535 5536
                    h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
                }
        }

lorenm's avatar
lorenm committed
5537 5538 5539
        if(dct8x8_allowed)
            dct8x8_allowed = get_dct8x8_allowed(h);

5540
        for(list=0; list<h->list_count; list++){
5541
            for(i=0; i<4; i++){
5542
                h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
5543 5544 5545 5546
                if(IS_DIRECT(h->sub_mb_type[i])){
                    fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
                    continue;
                }
5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560

                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
5561
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5562 5563

                        if(IS_SUB_8X8(sub_mb_type)){
5564
                            mv_cache[ 1 ][0]=
5565
                            mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
5566
                            mv_cache[ 1 ][1]=
5567 5568
                            mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;

5569
                            mvd_cache[ 1 ][0]=
5570
                            mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
5571
                            mvd_cache[ 1 ][1]=
5572 5573
                            mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
                        }else if(IS_SUB_8X4(sub_mb_type)){
5574 5575
                            mv_cache[ 1 ][0]= mx;
                            mv_cache[ 1 ][1]= my;
5576

5577 5578
                            mvd_cache[ 1 ][0]= mx - mpx;
                            mvd_cache[ 1 ][1]= my - mpy;
5579
                        }else if(IS_SUB_4X8(sub_mb_type)){
5580 5581
                            mv_cache[ 8 ][0]= mx;
                            mv_cache[ 8 ][1]= my;
5582

5583 5584
                            mvd_cache[ 8 ][0]= mx - mpx;
                            mvd_cache[ 8 ][1]= my - mpy;
5585
                        }
5586 5587 5588 5589 5590
                        mv_cache[ 0 ][0]= mx;
                        mv_cache[ 0 ][1]= my;

                        mvd_cache[ 0 ][0]= mx - mpx;
                        mvd_cache[ 0 ][1]= my - mpy;
5591 5592 5593 5594 5595 5596 5597 5598 5599
                    }
                }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;
                }
            }
        }
5600 5601 5602 5603
    } 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
5604
        dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
5605
    } else {
5606 5607
        int list, mx, my, i, mpx, mpy;
        if(IS_16X16(mb_type)){
michael's avatar
michael committed
5608
            for(list=0; list<h->list_count; list++){
5609
                if(IS_DIR(mb_type, 0, list)){
5610 5611 5612 5613 5614 5615 5616 5617 5618
                    int ref;
                    if(h->ref_count[list] > 1){
                        ref= decode_cabac_mb_ref(h, list, 0);
                        if(ref >= (unsigned)h->ref_count[list]){
                            av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
                            return -1;
                        }
                    }else
                        ref=0;
5619
                        fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
lorenm's avatar
lorenm committed
5620
                }else
michael's avatar
michael committed
5621
                    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
5622
            }
michael's avatar
michael committed
5623
            for(list=0; list<h->list_count; list++){
5624 5625 5626 5627 5628
                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
5629
                    tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5630 5631 5632

                    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
5633 5634
                }else
                    fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
5635 5636 5637
            }
        }
        else if(IS_16X8(mb_type)){
5638
            for(list=0; list<h->list_count; list++){
5639 5640
                    for(i=0; i<2; i++){
                        if(IS_DIR(mb_type, i, list)){
5641 5642 5643 5644 5645 5646 5647 5648 5649
                            int ref;
                            if(h->ref_count[list] > 1){
                                ref= decode_cabac_mb_ref( h, list, 8*i );
                                if(ref >= (unsigned)h->ref_count[list]){
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
                                    return -1;
                                }
                            }else
                                ref=0;
5650
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
5651 5652
                        }else
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
5653 5654
                    }
            }
5655
            for(list=0; list<h->list_count; list++){
5656 5657 5658 5659 5660
                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
5661
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5662 5663 5664

                        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
5665
                    }else{
5666 5667
                        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);
5668 5669 5670 5671 5672
                    }
                }
            }
        }else{
            assert(IS_8X16(mb_type));
5673
            for(list=0; list<h->list_count; list++){
5674 5675
                    for(i=0; i<2; i++){
                        if(IS_DIR(mb_type, i, list)){ //FIXME optimize
5676 5677 5678 5679 5680 5681 5682 5683 5684
                            int ref;
                            if(h->ref_count[list] > 1){
                                ref= decode_cabac_mb_ref( h, list, 4*i );
                                if(ref >= (unsigned)h->ref_count[list]){
                                    av_log(s->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, h->ref_count[list]);
                                    return -1;
                                }
                            }else
                                ref=0;
5685
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
5686 5687
                        }else
                            fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
5688 5689
                    }
            }
5690
            for(list=0; list<h->list_count; list++){
5691 5692 5693 5694 5695 5696
                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
5697
                        tprintf(s->avctx, "final mv:%d %d\n", mx, my);
5698 5699
                        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
5700
                    }else{
5701 5702
                        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);
5703 5704 5705 5706
                    }
                }
            }
        }
5707 5708
    }

5709 5710
   if( IS_INTER( mb_type ) ) {
        h->chroma_pred_mode_table[mb_xy] = 0;
5711
        write_back_motion( h, mb_type );
5712
   }
5713 5714 5715

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

lorenm's avatar
lorenm committed
5720
    h->cbp_table[mb_xy] = h->cbp = cbp;
5721

lorenm's avatar
lorenm committed
5722 5723 5724 5725 5726 5727
    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;

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

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

        h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
5744 5745 5746 5747
        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;
        }
5748 5749 5750 5751 5752
        s->qscale += dqp;
        if(((unsigned)s->qscale) > 51){
            if(s->qscale<0) s->qscale+= 52;
            else            s->qscale-= 52;
        }
5753 5754
        h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
        h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
5755 5756 5757 5758

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

5761
            if( cbp&15 ) {
5762
                qmul = h->dequant4_coeff[0][s->qscale];
5763 5764
                for( i = 0; i < 16; i++ ) {
                    //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
5765
                    decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, qmul, 15);
5766 5767 5768 5769 5770 5771 5772 5773
                }
            } 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
5774
                    if( IS_8x8DCT(mb_type) ) {
5775 5776
                        decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
                            scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64);
5777
                    } else {
andoma's avatar
andoma committed
5778 5779 5780 5781
                        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 );
5782
//START_TIMER
andoma's avatar
andoma committed
5783
                            decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, qmul, 16);
5784
//STOP_TIMER("decode_residual")
andoma's avatar
andoma committed
5785
                        }
5786
                    }
5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797
                } 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 );
5798
                decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4);
5799 5800 5801 5802 5803 5804
            }
        }

        if( cbp&0x20 ) {
            int c, i;
            for( c = 0; c < 2; c++ ) {
5805
                qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
5806 5807 5808
                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 );
5809
                    decode_cabac_residual(h, h->mb + 16*index, 4, index, scan + 1, qmul, 15);
5810 5811 5812 5813 5814 5815 5816 5817
                }
            }
        } 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
5818 5819 5820 5821
        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
5822
        h->last_qscale_diff = 0;
5823 5824 5825 5826 5827
    }

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

lorenm's avatar
lorenm committed
5828 5829 5830 5831 5832
    if(MB_MBAFF){
        h->ref_count[0] >>= 1;
        h->ref_count[1] >>= 1;
    }

5833 5834 5835 5836
    return 0;
}


5837
static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
5838 5839 5840
    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];
5841

lorenm's avatar
lorenm committed
5842
    if( bS[0] < 4 ) {
5843
        int8_t tc[4];
darkshikari's avatar
darkshikari committed
5844 5845 5846 5847
        tc[0] = (tc0_table+52)[index_a][bS[0]];
        tc[1] = (tc0_table+52)[index_a][bS[1]];
        tc[2] = (tc0_table+52)[index_a][bS[2]];
        tc[3] = (tc0_table+52)[index_a][bS[3]];
lorenm's avatar
lorenm committed
5848 5849
        h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
    } else {
5850
        h->s.dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
5851 5852
    }
}
5853
static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
5854 5855 5856
    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];
5857

lorenm's avatar
lorenm committed
5858
    if( bS[0] < 4 ) {
5859
        int8_t tc[4];
darkshikari's avatar
darkshikari committed
5860 5861 5862 5863
        tc[0] = (tc0_table+52)[index_a][bS[0]]+1;
        tc[1] = (tc0_table+52)[index_a][bS[1]]+1;
        tc[2] = (tc0_table+52)[index_a][bS[2]]+1;
        tc[3] = (tc0_table+52)[index_a][bS[3]]+1;
lorenm's avatar
lorenm committed
5864 5865
        h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
    } else {
5866
        h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
5867 5868 5869
    }
}

5870
static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
5871 5872 5873 5874 5875
    int i;
    for( i = 0; i < 16; i++, pix += stride) {
        int index_a;
        int alpha;
        int beta;
5876

5877 5878
        int qp_index;
        int bS_index = (i >> 1);
lorenm's avatar
lorenm committed
5879
        if (!MB_FIELD) {
5880 5881 5882 5883 5884 5885 5886 5887
            bS_index &= ~1;
            bS_index |= (i & 1);
        }

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

lorenm's avatar
lorenm committed
5888
        qp_index = MB_FIELD ? (i >> 3) : (i & 1);
5889 5890 5891
        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];
5892 5893

        if( bS[bS_index] < 4 ) {
darkshikari's avatar
darkshikari committed
5894
            const int tc0 = (tc0_table+52)[index_a][bS[bS_index]];
5895 5896 5897 5898 5899 5900 5901
            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
5902 5903 5904
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
5905 5906 5907
                int tc = tc0;
                int i_delta;

diego's avatar
diego committed
5908
                if( FFABS( p2 - p0 ) < beta ) {
reimar's avatar
reimar committed
5909
                    pix[-2] = p1 + av_clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
5910 5911
                    tc++;
                }
diego's avatar
diego committed
5912
                if( FFABS( q2 - q0 ) < beta ) {
reimar's avatar
reimar committed
5913
                    pix[1] = q1 + av_clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
5914 5915 5916
                    tc++;
                }

reimar's avatar
reimar committed
5917 5918 5919
                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
5920
                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);
5921 5922 5923 5924 5925 5926 5927 5928 5929 5930
            }
        }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
5931 5932 5933
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
5934

diego's avatar
diego committed
5935 5936
                if(FFABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
                    if( FFABS( p2 - p0 ) < beta)
5937 5938 5939 5940 5941 5942 5943 5944 5945 5946
                    {
                        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
5947
                    if( FFABS( q2 - q0 ) < beta)
5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962
                    {
                        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
5963
                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]);
5964 5965 5966 5967
            }
        }
    }
}
5968
static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int16_t bS[8], int qp[2] ) {
5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981
    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
5982
        qp_index = MB_FIELD ? (i >> 2) : (i & 1);
5983 5984 5985
        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
5986

5987
        if( bS[bS_index] < 4 ) {
darkshikari's avatar
darkshikari committed
5988
            const int tc = (tc0_table+52)[index_a][bS[bS_index]] + 1;
5989 5990 5991 5992 5993
            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
5994 5995 5996
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
reimar's avatar
reimar committed
5997
                const int i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
5998

reimar's avatar
reimar committed
5999 6000
                pix[-1] = av_clip_uint8( p0 + i_delta );    /* p0' */
                pix[0]  = av_clip_uint8( q0 - i_delta );    /* q0' */
mbardiaux's avatar
mbardiaux committed
6001
                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);
6002 6003 6004 6005 6006 6007 6008
            }
        }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
6009 6010 6011
            if( FFABS( p0 - q0 ) < alpha &&
                FFABS( p1 - p0 ) < beta &&
                FFABS( q1 - q0 ) < beta ) {
6012 6013 6014

                pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
                pix[0]  = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
mbardiaux's avatar
mbardiaux committed
6015
                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]);
6016 6017 6018 6019 6020
            }
        }
    }
}

6021
static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6022 6023 6024
    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];
6025

lorenm's avatar
lorenm committed
6026
    if( bS[0] < 4 ) {
6027
        int8_t tc[4];
darkshikari's avatar
darkshikari committed
6028 6029 6030 6031
        tc[0] = (tc0_table+52)[index_a][bS[0]];
        tc[1] = (tc0_table+52)[index_a][bS[1]];
        tc[2] = (tc0_table+52)[index_a][bS[2]];
        tc[3] = (tc0_table+52)[index_a][bS[3]];
lorenm's avatar
lorenm committed
6032 6033
        h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
    } else {
6034
        h->s.dsp.h264_v_loop_filter_luma_intra(pix, stride, alpha, beta);
6035 6036 6037
    }
}

6038
static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) {
6039 6040 6041
    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];
6042

lorenm's avatar
lorenm committed
6043
    if( bS[0] < 4 ) {
6044
        int8_t tc[4];
darkshikari's avatar
darkshikari committed
6045 6046 6047 6048
        tc[0] = (tc0_table+52)[index_a][bS[0]]+1;
        tc[1] = (tc0_table+52)[index_a][bS[1]]+1;
        tc[2] = (tc0_table+52)[index_a][bS[2]]+1;
        tc[3] = (tc0_table+52)[index_a][bS[3]]+1;
lorenm's avatar
lorenm committed
6049 6050
        h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
    } else {
6051
        h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
6052 6053 6054
    }
}

6055 6056
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;
6057
    int mb_y_firstrow = s->picture_structure == PICT_BOTTOM_FIELD;
6058 6059 6060
    int mb_xy, mb_type;
    int qp, qp0, qp1, qpc, qpc0, qpc1, qp_thresh;

6061
    mb_xy = h->mb_xy;
6062

6063
    if(mb_x==0 || mb_y==mb_y_firstrow || !s->dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff ||
6064
        !(s->flags2 & CODEC_FLAG2_FAST) || //FIXME filter_mb_fast is broken, thus hasto be, but should not under CODEC_FLAG2_FAST
6065 6066
       (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]))) {
6067 6068 6069 6070 6071 6072 6073 6074 6075
        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];
6076 6077 6078
    qpc = get_chroma_qp( h, 0, qp );
    qpc0 = get_chroma_qp( h, 0, qp0 );
    qpc1 = get_chroma_qp( h, 0, qp1 );
6079 6080 6081 6082
    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
6083 6084 6085 6086
    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;
6087 6088 6089 6090

    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
6091
        int16_t *bSH = FIELD_PICTURE ? bS3 : bS4;
6092 6093 6094
        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
6095
            filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bSH, qp1 );
6096 6097 6098 6099 6100 6101
            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
6102
            filter_mb_edgeh( h, &img_y[4*0*linesize], linesize, bSH, qp1 );
6103 6104 6105 6106 6107 6108 6109 6110
            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
6111
        filter_mb_edgech( h, &img_cb[2*0*uvlinesize], uvlinesize, bSH, qpc1 );
6112
        filter_mb_edgech( h, &img_cb[2*2*uvlinesize], uvlinesize, bS3, qpc );
andoma's avatar
andoma committed
6113
        filter_mb_edgech( h, &img_cr[2*0*uvlinesize], uvlinesize, bSH, qpc1 );
6114 6115 6116 6117 6118
        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
6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131
        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,
6132
                                              (h->slice_type_nos == FF_B_TYPE), edges, step, mask_edge0, mask_edge1, FIELD_PICTURE);
lorenm's avatar
lorenm committed
6133
        }
6134
        if( IS_INTRA(s->current_picture.mb_type[mb_xy-1]) )
6135
            bSv[0][0] = 0x0004000400040004ULL;
6136
        if( IS_INTRA(s->current_picture.mb_type[h->top_mb_xy]) )
6137
            bSv[1][0] = FIELD_PICTURE ? 0x0003000300030003ULL : 0x0004000400040004ULL;
6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168

#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
    }
}

6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 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 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

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
6311 6312
                if( h->non_zero_count_cache[b_idx] |
                    h->non_zero_count_cache[bn_idx] ) {
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
                    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);
            }
        }
    }
}

6373
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) {
6374 6375
    MpegEncContext * const s = &h->s;
    const int mb_xy= mb_x + mb_y*s->mb_stride;
lorenm's avatar
lorenm committed
6376 6377
    const int mb_type = s->current_picture.mb_type[mb_xy];
    const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
6378
    int first_vertical_edge_done = 0;
6379 6380
    int dir;

lorenm's avatar
lorenm committed
6381 6382
    //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
6383
    if(!FRAME_MBAFF){
6384
        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
6385 6386 6387 6388 6389 6390 6391 6392
        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
6393 6394 6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415 6416
    // 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
6417
            h->non_zero_count_cache[scan8[2   ]]= h->non_zero_count_cache[scan8[3   ]]= h->cbp & 1;
michael's avatar
michael committed
6418 6419

            h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
michael's avatar
michael committed
6420
            h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
michael's avatar
michael committed
6421 6422

            h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
michael's avatar
michael committed
6423
            h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
michael's avatar
michael committed
6424 6425

            h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
michael's avatar
michael committed
6426
            h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
michael's avatar
michael committed
6427 6428 6429
        }
    }

lorenm's avatar
lorenm committed
6430
    if (FRAME_MBAFF
6431
            // left mb is in picture
6432
            && h->slice_table[mb_xy-1] != 0xFFFF
6433
            // and current and left pair do not have the same interlaced type
lorenm's avatar
lorenm committed
6434
            && (IS_INTERLACED(mb_type) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
6435 6436 6437
            // 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
6438
         * There are 8 different bS to compute and 2 different Qp
6439
         */
lorenm's avatar
lorenm committed
6440 6441
        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 };
6442
        int16_t bS[8];
6443
        int qp[2];
6444 6445
        int bqp[2];
        int rqp[2];
lorenm's avatar
lorenm committed
6446
        int mb_qp, mbn0_qp, mbn1_qp;
6447 6448
        int i;
        first_vertical_edge_done = 1;
lorenm's avatar
lorenm committed
6449 6450 6451 6452 6453 6454 6455 6456 6457 6458

        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
6459 6460 6461 6462
                         ((!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
6463 6464 6465
                    bS[i] = 2;
                else
                    bS[i] = 1;
6466 6467 6468
            }
        }

lorenm's avatar
lorenm committed
6469 6470 6471 6472
        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;
6473 6474 6475 6476
        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
6477
        qp[1] = ( mb_qp + mbn1_qp + 1 ) >> 1;
6478 6479 6480 6481
        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
6482 6483

        /* Filter edge */
6484
        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
6485
        { 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
6486
        filter_mb_mbaff_edgev ( h, &img_y [0], linesize,   bS, qp );
6487 6488
        filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, bqp );
        filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, rqp );
6489
    }
6490

6491 6492 6493 6494 6495 6496 6497
#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
6498 6499
}

6500 6501
static int decode_slice(struct AVCodecContext *avctx, void *arg){
    H264Context *h = *(void**)arg;
michaelni's avatar
michaelni committed
6502 6503 6504 6505 6506
    MpegEncContext * const s = &h->s;
    const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;

    s->mb_skip_run= -1;

6507
    h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
6508
                    (ENABLE_GRAY && (s->flags&CODEC_FLAG_GRAY)) || (ENABLE_H264_ENCODER && s->encoding);
6509

6510 6511
    if( h->pps.cabac ) {
        int i;
michaelni's avatar
michaelni committed
6512

6513 6514 6515 6516
        /* realign */
        align_get_bits( &s->gb );

        /* init cabac */
6517
        ff_init_cabac_states( &h->cabac);
6518 6519
        ff_init_cabac_decoder( &h->cabac,
                               s->gb.buffer + get_bits_count(&s->gb)/8,
michael's avatar
michael committed
6520
                               ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
6521
        /* calculate pre-state */
lorenm's avatar
lorenm committed
6522
        for( i= 0; i < 460; i++ ) {
6523
            int pre;
6524
            if( h->slice_type_nos == FF_I_TYPE )
reimar's avatar
reimar committed
6525
                pre = av_clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
6526
            else
reimar's avatar
reimar committed
6527
                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 );
6528 6529

            if( pre <= 63 )
6530
                h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
6531
            else
6532
                h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
michaelni's avatar
michaelni committed
6533
        }
6534

6535
        for(;;){
6536
//START_TIMER
6537
            int ret = decode_mb_cabac(h);
6538
            int eos;
6539
//STOP_TIMER("decode_mb_cabac")
michaelni's avatar
michaelni committed
6540

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

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

michael's avatar
michael committed
6546
                ret = decode_mb_cabac(h);
6547

6548
                if(ret>=0) hl_decode_mb(h);
6549 6550
                s->mb_y--;
            }
6551
            eos = get_cabac_terminate( &h->cabac );
6552

6553
            if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
mru's avatar
mru committed
6554
                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);
6555 6556 6557 6558 6559 6560 6561
                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
6562
                ++s->mb_y;
6563
                if(FIELD_OR_MBAFF_PICTURE) {
6564 6565
                    ++s->mb_y;
                }
michaelni's avatar
michaelni committed
6566 6567
            }

6568
            if( eos || s->mb_y >= s->mb_height ) {
mbardiaux's avatar
mbardiaux committed
6569
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6570
                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
6571
                return 0;
6572 6573 6574 6575 6576 6577 6578
            }
        }

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

michael's avatar
michael committed
6579
            if(ret>=0) hl_decode_mb(h);
6580

lorenm's avatar
lorenm committed
6581
            if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
6582 6583 6584
                s->mb_y++;
                ret = decode_mb_cavlc(h);

michael's avatar
michael committed
6585
                if(ret>=0) hl_decode_mb(h);
6586 6587 6588 6589 6590
                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
6591 6592 6593 6594
                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;
            }
6595 6596 6597 6598

            if(++s->mb_x >= s->mb_width){
                s->mb_x=0;
                ff_draw_horiz_band(s, 16*s->mb_y, 16);
6599
                ++s->mb_y;
6600
                if(FIELD_OR_MBAFF_PICTURE) {
6601 6602 6603
                    ++s->mb_y;
                }
                if(s->mb_y >= s->mb_height){
mbardiaux's avatar
mbardiaux committed
6604
                    tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618

                    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
6619
                tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6620 6621 6622 6623 6624 6625 6626 6627 6628 6629
                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
6630 6631
        }
    }
6632

michaelni's avatar
michaelni committed
6633 6634 6635 6636
#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);
6637

michaelni's avatar
michaelni committed
6638 6639 6640
            hl_decode_mb(h);

            if(ret<0){
diego's avatar
diego committed
6641
                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
6642 6643 6644 6645
                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;
            }
6646

michaelni's avatar
michaelni committed
6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660
            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;
                    }
                }
            }
6661

michaelni's avatar
michaelni committed
6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680
            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
}

6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706 6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727
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;
}

6728 6729 6730 6731
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;
6732

6733 6734
    if(size<16)
        return -1;
6735

6736 6737 6738
    for(i=0; i<sizeof(user_data)-1 && i<size; i++){
        user_data[i]= get_bits(&s->gb, 8);
    }
6739

6740 6741 6742 6743
    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;
6744

6745 6746 6747 6748 6749
    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);
6750

6751 6752 6753 6754 6755
    return 0;
}

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

6757 6758
    while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
        int size, type;
6759

6760 6761 6762 6763
        type=0;
        do{
            type+= show_bits(&s->gb, 8);
        }while(get_bits(&s->gb, 8) == 255);
6764

6765 6766 6767 6768
        size=0;
        do{
            size+= show_bits(&s->gb, 8);
        }while(get_bits(&s->gb, 8) == 255);
6769

6770
        switch(type){
6771 6772 6773 6774
        case 1: // Picture timing SEI
            if(decode_picture_timing(h) < 0)
                return -1;
            break;
6775
        case 5:
michael's avatar
michael committed
6776
            if(decode_unregistered_user_data(h, size) < 0)
6777 6778 6779 6780 6781
                return -1;
            break;
        default:
            skip_bits(&s->gb, 8*size);
        }
6782

6783 6784 6785 6786 6787 6788 6789
        //FIXME check bits here
        align_get_bits(&s->gb);
    }

    return 0;
}

6790
static inline int decode_hrd_parameters(H264Context *h, SPS *sps){
6791 6792 6793
    MpegEncContext * const s = &h->s;
    int cpb_count, i;
    cpb_count = get_ue_golomb(&s->gb) + 1;
6794 6795 6796 6797 6798 6799

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

6800 6801 6802 6803 6804 6805 6806 6807
    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 */
6808 6809 6810
    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);
6811
    return 0;
6812 6813
}

michaelni's avatar
michaelni committed
6814 6815
static inline int decode_vui_parameters(H264Context *h, SPS *sps){
    MpegEncContext * const s = &h->s;
6816 6817
    int aspect_ratio_info_present_flag;
    unsigned int aspect_ratio_idc;
michaelni's avatar
michaelni committed
6818 6819

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

michaelni's avatar
michaelni committed
6821 6822 6823
    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
6824 6825
            sps->sar.num= get_bits(&s->gb, 16);
            sps->sar.den= get_bits(&s->gb, 16);
6826
        }else if(aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)){
michael's avatar
michael committed
6827
            sps->sar=  pixel_aspect[aspect_ratio_idc];
michaelni's avatar
michaelni committed
6828
        }else{
6829
            av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
michaelni's avatar
michaelni committed
6830 6831 6832
            return -1;
        }
    }else{
6833
        sps->sar.num=
michael's avatar
michael committed
6834
        sps->sar.den= 0;
michaelni's avatar
michaelni committed
6835 6836
    }
//            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863

    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);
    }

6864 6865
    sps->nal_hrd_parameters_present_flag = get_bits1(&s->gb);
    if(sps->nal_hrd_parameters_present_flag)
6866 6867
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
6868 6869
    sps->vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
    if(sps->vcl_hrd_parameters_present_flag)
6870 6871
        if(decode_hrd_parameters(h, sps) < 0)
            return -1;
6872
    if(sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag)
6873
        get_bits1(&s->gb);     /* low_delay_hrd_flag */
6874
    sps->pic_struct_present_flag = get_bits1(&s->gb);
6875 6876 6877 6878 6879 6880 6881 6882

    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 */
6883
        sps->num_reorder_frames= get_ue_golomb(&s->gb);
6884 6885
        get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/

6886 6887
        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);
6888 6889
            return -1;
        }
6890 6891
    }

michaelni's avatar
michaelni committed
6892 6893 6894
    return 0;
}

6895 6896
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
6897 6898 6899
    MpegEncContext * const s = &h->s;
    int i, last = 8, next = 8;
    const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
6900 6901
    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
6902 6903 6904 6905
    else
    for(i=0;i<size;i++){
        if(next)
            next = (last + get_se_golomb(&s->gb)) & 0xff;
6906 6907
        if(!i && !next){ /* matrix not written, we use the preset one */
            memcpy(factors, jvt_list, size*sizeof(uint8_t));
lorenm's avatar
lorenm committed
6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925
            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;
6926 6927 6928 6929 6930 6931
        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
6932
        if(is_sps || pps->transform_8x8_mode){
6933 6934
            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
6935 6936 6937 6938
        }
    }
}

michaelni's avatar
michaelni committed
6939 6940
static inline int decode_seq_parameter_set(H264Context *h){
    MpegEncContext * const s = &h->s;
michaelni's avatar
michaelni committed
6941
    int profile_idc, level_idc;
6942
    unsigned int sps_id;
6943
    int i;
michaelni's avatar
michaelni committed
6944
    SPS *sps;
6945

michaelni's avatar
michaelni committed
6946
    profile_idc= get_bits(&s->gb, 8);
michaelni's avatar
michaelni committed
6947 6948 6949
    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
6950 6951
    get_bits1(&s->gb);   //constraint_set3_flag
    get_bits(&s->gb, 4); // reserved
michaelni's avatar
michaelni committed
6952 6953
    level_idc= get_bits(&s->gb, 8);
    sps_id= get_ue_golomb(&s->gb);
6954

6955 6956 6957 6958 6959
    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
6960
    if(sps == NULL)
6961 6962
        return -1;

michaelni's avatar
michaelni committed
6963 6964
    sps->profile_idc= profile_idc;
    sps->level_idc= level_idc;
michael's avatar
michael committed
6965

6966 6967 6968 6969
    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
6970
    if(sps->profile_idc >= 100){ //high profile
6971 6972
        sps->chroma_format_idc= get_ue_golomb(&s->gb);
        if(sps->chroma_format_idc == 3)
lorenm's avatar
lorenm committed
6973 6974 6975
            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
6976
        sps->transform_bypass = get_bits1(&s->gb);
lorenm's avatar
lorenm committed
6977
        decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
6978 6979 6980
    }else{
        sps->chroma_format_idc= 1;
    }
lorenm's avatar
lorenm committed
6981

michaelni's avatar
michaelni committed
6982 6983
    sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
    sps->poc_type= get_ue_golomb(&s->gb);
6984

michaelni's avatar
michaelni committed
6985 6986 6987 6988 6989 6990
    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);
6991
        sps->poc_cycle_length                = get_ue_golomb(&s->gb);
6992

6993 6994
        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);
6995
            goto fail;
6996
        }
6997

michaelni's avatar
michaelni committed
6998 6999
        for(i=0; i<sps->poc_cycle_length; i++)
            sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
7000
    }else if(sps->poc_type != 2){
7001
        av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
7002
        goto fail;
michaelni's avatar
michaelni committed
7003 7004
    }

7005 7006
    sps->ref_frame_count= get_ue_golomb(&s->gb);
    if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
7007
        av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
7008
        goto fail;
7009
    }
michaelni's avatar
michaelni committed
7010
    sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
7011 7012 7013 7014
    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)){
7015
        av_log(h->s.avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
7016
        goto fail;
7017
    }
7018

michaelni's avatar
michaelni committed
7019 7020 7021 7022 7023 7024 7025 7026
    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
7027 7028
#ifndef ALLOW_INTERLACE
    if(sps->mb_aff)
diego's avatar
diego committed
7029
        av_log(h->s.avctx, AV_LOG_ERROR, "MBAFF support not included; enable it at compile-time.\n");
lorenm's avatar
lorenm committed
7030
#endif
michaelni's avatar
michaelni committed
7031 7032 7033 7034 7035 7036 7037
    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){
7038
            av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
michaelni's avatar
michaelni committed
7039
        }
7040
        if(sps->crop_right >= 8 || sps->crop_bottom >= (8>> !sps->frame_mbs_only_flag)){
7041 7042
            av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
        }
michaelni's avatar
michaelni committed
7043
    }else{
7044 7045 7046
        sps->crop_left  =
        sps->crop_right =
        sps->crop_top   =
michaelni's avatar
michaelni committed
7047 7048 7049
        sps->crop_bottom= 0;
    }

michaelni's avatar
michaelni committed
7050 7051 7052
    sps->vui_parameters_present_flag= get_bits1(&s->gb);
    if( sps->vui_parameters_present_flag )
        decode_vui_parameters(h, sps);
7053

michaelni's avatar
michaelni committed
7054
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7055
        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
7056 7057 7058 7059 7060 7061
               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" : "",
7062 7063
               sps->crop_left, sps->crop_right,
               sps->crop_top, sps->crop_bottom,
7064 7065
               sps->vui_parameters_present_flag ? "VUI" : "",
               ((const char*[]){"Gray","420","422","444"})[sps->chroma_format_idc]
michaelni's avatar
michaelni committed
7066 7067
               );
    }
7068 7069
    av_free(h->sps_buffers[sps_id]);
    h->sps_buffers[sps_id]= sps;
michaelni's avatar
michaelni committed
7070
    return 0;
7071 7072 7073
fail:
    av_free(sps);
    return -1;
michaelni's avatar
michaelni committed
7074 7075
}

7076
static void
7077
build_qp_table(PPS *pps, int t, int index)
7078 7079
{
    int i;
7080 7081
    for(i = 0; i < 52; i++)
        pps->chroma_qp_table[t][i] = chroma_qp[av_clip(i + index, 0, 51)];
7082 7083
}

lorenm's avatar
lorenm committed
7084
static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
michaelni's avatar
michaelni committed
7085
    MpegEncContext * const s = &h->s;
7086
    unsigned int pps_id= get_ue_golomb(&s->gb);
7087 7088
    PPS *pps;

7089 7090
    if(pps_id >= MAX_PPS_COUNT) {
        av_log(h->s.avctx, AV_LOG_ERROR, "pps_id (%d) out of range\n", pps_id);
7091
        return -1;
7092
    }
7093

7094 7095 7096
    pps= av_mallocz(sizeof(PPS));
    if(pps == NULL)
        return -1;
7097 7098 7099 7100 7101
    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;
    }
7102

michaelni's avatar
michaelni committed
7103 7104 7105 7106 7107
    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);
7108
        av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
michaelni's avatar
michaelni committed
7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139
        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
7140
            break;
michaelni's avatar
michaelni committed
7141 7142 7143 7144
        }
    }
    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
7145
    if(pps->ref_count[0]-1 > 32-1 || pps->ref_count[1]-1 > 32-1){
7146
        av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
7147
        goto fail;
michaelni's avatar
michaelni committed
7148
    }
7149

michaelni's avatar
michaelni committed
7150 7151 7152 7153
    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;
7154
    pps->chroma_qp_index_offset[0]= get_se_golomb(&s->gb);
michaelni's avatar
michaelni committed
7155 7156 7157
    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);
7158

7159 7160
    pps->transform_8x8_mode= 0;
    h->dequant_coeff_pps= -1; //contents of sps/pps can change even if id doesn't, so reinit
7161 7162
    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
7163 7164 7165

    if(get_bits_count(&s->gb) < bit_length){
        pps->transform_8x8_mode= get_bits1(&s->gb);
benoit's avatar
 
benoit committed
7166
        decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
7167 7168 7169
        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
7170
    }
7171

7172
    build_qp_table(pps, 0, pps->chroma_qp_index_offset[0]);
7173 7174
    build_qp_table(pps, 1, pps->chroma_qp_index_offset[1]);
    if(pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
7175 7176
        h->pps.chroma_qp_diff= 1;

michaelni's avatar
michaelni committed
7177
    if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7178
        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
7179 7180 7181 7182 7183
               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" : "",
7184
               pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset[0], pps->chroma_qp_index_offset[1],
michaelni's avatar
michaelni committed
7185 7186
               pps->deblocking_filter_parameters_present ? "LPAR" : "",
               pps->constrained_intra_pred ? "CONSTR" : "",
lorenm's avatar
lorenm committed
7187 7188
               pps->redundant_pic_cnt_present ? "REDU" : "",
               pps->transform_8x8_mode ? "8x8DCT" : ""
michaelni's avatar
michaelni committed
7189 7190
               );
    }
7191

7192 7193
    av_free(h->pps_buffers[pps_id]);
    h->pps_buffers[pps_id]= pps;
michaelni's avatar
michaelni committed
7194
    return 0;
7195 7196 7197
fail:
    av_free(pps);
    return -1;
michaelni's avatar
michaelni committed
7198 7199
}

7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212
/**
 * 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
7213
        decode_slice(avctx, &h);
7214 7215 7216
    } else {
        for(i = 1; i < context_count; i++) {
            hx = h->thread_context[i];
7217
            hx->s.error_recognition = avctx->error_recognition;
7218 7219 7220 7221
            hx->s.error_count = 0;
        }

        avctx->execute(avctx, (void *)decode_slice,
7222
                       (void **)h->thread_context, NULL, context_count, sizeof(void*));
7223 7224 7225 7226 7227

        /* 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;
7228 7229
        s->dropable = hx->s.dropable;
        s->picture_structure = hx->s.picture_structure;
7230 7231 7232 7233 7234 7235
        for(i = 1; i < context_count; i++)
            h->s.error_count += h->thread_context[i]->s.error_count;
    }
}


michael's avatar
michael committed
7236
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
michaelni's avatar
michaelni committed
7237 7238 7239
    MpegEncContext * const s = &h->s;
    AVCodecContext * const avctx= s->avctx;
    int buf_index=0;
7240 7241 7242 7243
    H264Context *hx; ///< thread context
    int context_count = 0;

    h->max_contexts = avctx->thread_count;
michaelni's avatar
michaelni committed
7244
#if 0
al3x's avatar
al3x committed
7245
    int i;
7246 7247
    for(i=0; i<50; i++){
        av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
michaelni's avatar
michaelni committed
7248 7249
    }
#endif
7250
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
7251
        h->current_slice = 0;
7252
        if (!s->first_field)
andoma's avatar
andoma committed
7253
            s->current_picture_ptr= NULL;
7254 7255
    }

michaelni's avatar
michaelni committed
7256 7257 7258 7259
    for(;;){
        int consumed;
        int dst_length;
        int bit_length;
michael's avatar
michael committed
7260
        const uint8_t *ptr;
7261
        int i, nalsize = 0;
7262
        int err;
7263

benoit's avatar
benoit committed
7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283
        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;
7284
            }
7285

benoit's avatar
benoit committed
7286
            if(buf_index+3 >= buf_size) break;
7287

benoit's avatar
benoit committed
7288 7289
            buf_index+=3;
        }
7290

7291 7292 7293
        hx = h->thread_context[context_count];

        ptr= decode_nal(hx, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
7294
        if (ptr==NULL || dst_length < 0){
7295 7296
            return -1;
        }
7297
        while(ptr[dst_length - 1] == 0 && dst_length > 0)
7298
            dst_length--;
7299
        bit_length= !dst_length ? 0 : (8*dst_length - decode_rbsp_trailing(h, ptr + dst_length - 1));
michaelni's avatar
michaelni committed
7300 7301

        if(s->avctx->debug&FF_DEBUG_STARTCODE){
7302
            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
7303
        }
7304

7305
        if (h->is_avc && (nalsize != consumed)){
7306
            av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
7307 7308
            consumed= nalsize;
        }
7309

michaelni's avatar
michaelni committed
7310 7311
        buf_index += consumed;

diego's avatar
diego committed
7312
        if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME do not discard SEI id
michael's avatar
michael committed
7313
           ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))
michaelni's avatar
michaelni committed
7314
            continue;
7315

7316 7317 7318
      again:
        err = 0;
        switch(hx->nal_unit_type){
michaelni's avatar
michaelni committed
7319
        case NAL_IDR_SLICE:
7320 7321 7322 7323
            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;
            }
7324
            idr(h); //FIXME ensure we don't loose some frames if there is reordering
michaelni's avatar
michaelni committed
7325
        case NAL_SLICE:
7326 7327 7328 7329 7330 7331 7332 7333
            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;

7334
            s->current_picture_ptr->key_frame|= (hx->nal_unit_type == NAL_IDR_SLICE);
7335 7336
            if(hx->redundant_pic_count==0 && hx->s.hurry_up < 5
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
7337
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)
7338
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
michael's avatar
michael committed
7339
               && avctx->skip_frame < AVDISCARD_ALL)
7340
                context_count++;
michaelni's avatar
michaelni committed
7341 7342
            break;
        case NAL_DPA:
7343 7344 7345 7346
            init_get_bits(&hx->s.gb, ptr, bit_length);
            hx->intra_gb_ptr=
            hx->inter_gb_ptr= NULL;
            hx->s.data_partitioning = 1;
7347

7348
            err = decode_slice_header(hx, h);
michaelni's avatar
michaelni committed
7349 7350
            break;
        case NAL_DPB:
7351 7352
            init_get_bits(&hx->intra_gb, ptr, bit_length);
            hx->intra_gb_ptr= &hx->intra_gb;
michaelni's avatar
michaelni committed
7353 7354
            break;
        case NAL_DPC:
7355 7356
            init_get_bits(&hx->inter_gb, ptr, bit_length);
            hx->inter_gb_ptr= &hx->inter_gb;
michaelni's avatar
michaelni committed
7357

7358
            if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning
7359
               && s->context_initialized
michael's avatar
michael committed
7360
               && s->hurry_up < 5
7361
               && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
7362
               && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=FF_B_TYPE)
7363
               && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE)
michael's avatar
michael committed
7364
               && avctx->skip_frame < AVDISCARD_ALL)
7365
                context_count++;
michaelni's avatar
michaelni committed
7366 7367
            break;
        case NAL_SEI:
7368 7369
            init_get_bits(&s->gb, ptr, bit_length);
            decode_sei(h);
michaelni's avatar
michaelni committed
7370 7371 7372 7373
            break;
        case NAL_SPS:
            init_get_bits(&s->gb, ptr, bit_length);
            decode_seq_parameter_set(h);
7374

michaelni's avatar
michaelni committed
7375 7376
            if(s->flags& CODEC_FLAG_LOW_DELAY)
                s->low_delay=1;
7377

7378 7379
            if(avctx->has_b_frames < 2)
                avctx->has_b_frames= !s->low_delay;
michaelni's avatar
michaelni committed
7380 7381 7382
            break;
        case NAL_PPS:
            init_get_bits(&s->gb, ptr, bit_length);
7383

lorenm's avatar
lorenm committed
7384
            decode_picture_parameter_set(h, bit_length);
michaelni's avatar
michaelni committed
7385 7386

            break;
lorenm's avatar
lorenm committed
7387 7388 7389 7390 7391 7392
        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
7393
            break;
7394
        default:
7395
            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", h->nal_unit_type, bit_length);
7396 7397
        }

7398 7399 7400 7401 7402 7403 7404 7405 7406 7407
        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
7408
             * rbsp_buffer is not transferred, but since we no longer
7409 7410 7411 7412 7413 7414 7415 7416 7417
             * 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
7418 7419 7420 7421
    return buf_index;
}

/**
7422
 * returns the number of bytes consumed for building the current frame
michaelni's avatar
michaelni committed
7423 7424
 */
static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
diego's avatar
diego committed
7425
        if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
michaelni's avatar
michaelni committed
7426 7427 7428 7429 7430
        if(pos+10>buf_size) pos=buf_size; // oops ;)

        return pos;
}

7431
static int decode_frame(AVCodecContext *avctx,
michaelni's avatar
michaelni committed
7432
                             void *data, int *data_size,
michael's avatar
michael committed
7433
                             const uint8_t *buf, int buf_size)
michaelni's avatar
michaelni committed
7434 7435 7436
{
    H264Context *h = avctx->priv_data;
    MpegEncContext *s = &h->s;
7437
    AVFrame *pict = data;
michaelni's avatar
michaelni committed
7438
    int buf_index;
7439

michaelni's avatar
michaelni committed
7440
    s->flags= avctx->flags;
7441
    s->flags2= avctx->flags2;
michaelni's avatar
michaelni committed
7442

diego's avatar
diego committed
7443
   /* end of stream, output what is still in the buffers */
michaelni's avatar
michaelni committed
7444
    if (buf_size == 0) {
michael's avatar
michael committed
7445 7446 7447 7448 7449 7450
        Picture *out;
        int i, out_idx;

//FIXME factorize this with the output code below
        out = h->delayed_pic[0];
        out_idx = 0;
7451
        for(i=1; h->delayed_pic[i] && (h->delayed_pic[i]->poc && !h->delayed_pic[i]->key_frame); i++)
michael's avatar
michael committed
7452 7453 7454 7455 7456 7457 7458 7459 7460 7461 7462 7463 7464
            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
7465 7466
        return 0;
    }
7467

7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 7482 7483 7484 7485
    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++) {
7486
            nalsize = AV_RB16(p) + 2;
7487
            if(decode_nal_units(h, p, nalsize) < 0) {
7488 7489 7490 7491
                av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
                return -1;
            }
            p += nalsize;
7492
        }
7493 7494 7495
        // Decode pps from avcC
        cnt = *(p++); // Number of pps
        for (i = 0; i < cnt; i++) {
7496
            nalsize = AV_RB16(p) + 2;
7497 7498 7499 7500 7501
            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;
7502
        }
7503 7504 7505 7506 7507 7508
        // 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;
    }

7509
    if(!h->got_avcC && !h->is_avc && s->avctx->extradata_size){
7510
        if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
michaelni's avatar
michaelni committed
7511
            return -1;
7512
        h->got_avcC = 1;
michaelni's avatar
michaelni committed
7513 7514 7515
    }

    buf_index=decode_nal_units(h, buf, buf_size);
7516
    if(buf_index < 0)
michaelni's avatar
michaelni committed
7517 7518
        return -1;

7519
    if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){
7520
        if (avctx->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0;
7521 7522 7523 7524
        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
        return -1;
    }

7525 7526 7527 7528
    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;
7529

7530 7531 7532 7533 7534
        s->mb_y= 0;

        s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
        s->current_picture_ptr->pict_type= s->pict_type;

7535
        if(!s->dropable) {
michael's avatar
michael committed
7536
            execute_ref_pic_marking(h, h->mmco, h->mmco_index);
7537 7538
            h->prev_poc_msb= h->poc_msb;
            h->prev_poc_lsb= h->poc_lsb;
7539
        }
michael's avatar
michael committed
7540 7541
        h->prev_frame_num_offset= h->frame_num_offset;
        h->prev_frame_num= h->frame_num;
7542

7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555
        /*
         * 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
7556
            ff_er_frame_end(s);
7557 7558 7559

        MPV_frame_end(s);

7560
        if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
7561 7562 7563 7564
            /* Wait for second field. */
            *data_size = 0;

        } else {
7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618
            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;
                }
            }
7619

andoma's avatar
andoma committed
7620
        //FIXME do something with unavailable reference frames
michaelni's avatar
michaelni committed
7621

andoma's avatar
andoma committed
7622
            /* Sort B-frames into display order */
7623

andoma's avatar
andoma committed
7624 7625 7626 7627 7628
            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;
            }
7629

7630 7631 7632 7633 7634 7635
            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
7636 7637
            pics = 0;
            while(h->delayed_pic[pics]) pics++;
7638

7639
            assert(pics <= MAX_DELAYED_PIC_COUNT);
7640

andoma's avatar
andoma committed
7641 7642 7643
            h->delayed_pic[pics++] = cur;
            if(cur->reference == 0)
                cur->reference = DELAYED_PIC_REF;
7644

andoma's avatar
andoma committed
7645 7646
            out = h->delayed_pic[0];
            out_idx = 0;
7647
            for(i=1; h->delayed_pic[i] && (h->delayed_pic[i]->poc && !h->delayed_pic[i]->key_frame); i++)
andoma's avatar
andoma committed
7648 7649 7650 7651
                if(h->delayed_pic[i]->poc < out->poc){
                    out = h->delayed_pic[i];
                    out_idx = i;
                }
7652
            cross_idr = !h->delayed_pic[0]->poc || !!h->delayed_pic[i] || h->delayed_pic[0]->key_frame;
lorenm's avatar
lorenm committed
7653

7654
            out_of_order = !cross_idr && out->poc < h->outputed_poc;
7655

andoma's avatar
andoma committed
7656 7657
            if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
                { }
7658
            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
7659
               || (s->low_delay &&
7660
                ((!cross_idr && out->poc > h->outputed_poc + 2)
7661
                 || cur->pict_type == FF_B_TYPE)))
andoma's avatar
andoma committed
7662 7663 7664 7665 7666 7667
            {
                s->low_delay = 0;
                s->avctx->has_b_frames++;
            }

            if(out_of_order || pics > s->avctx->has_b_frames){
michael's avatar
michael committed
7668
                out->reference &= ~DELAYED_PIC_REF;
andoma's avatar
andoma committed
7669 7670 7671
                for(i=out_idx; h->delayed_pic[i]; i++)
                    h->delayed_pic[i] = h->delayed_pic[i+1];
            }
michael's avatar
michael committed
7672
            if(!out_of_order && pics > s->avctx->has_b_frames){
andoma's avatar
andoma committed
7673
                *data_size = sizeof(AVFrame);
7674 7675

                h->outputed_poc = out->poc;
andoma's avatar
andoma committed
7676
                *pict= *(AVFrame*)out;
michael's avatar
michael committed
7677
            }else{
andoma's avatar
andoma committed
7678
                av_log(avctx, AV_LOG_DEBUG, "no picture\n");
michael's avatar
michael committed
7679
            }
7680
        }
lorenm's avatar
lorenm committed
7681 7682
    }

7683
    assert(pict->data[0] || !*data_size);
7684
    ff_print_debug_info(s, pict);
michaelni's avatar
michaelni committed
7685 7686 7687 7688
//printf("out %d\n", (int)pict->data[0]);
#if 0 //?

    /* Return the Picture timestamp as the frame number */
vitor's avatar
vitor committed
7689
    /* we subtract 1 because it is added on utils.c     */
michaelni's avatar
michaelni committed
7690 7691 7692 7693 7694 7695 7696
    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;
7697
    const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
michaelni's avatar
michaelni committed
7698 7699

    if(s->mb_y){
7700 7701 7702
        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
7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713
    }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

7714
#ifdef TEST
7715
#undef printf
7716
#undef random
michaelni's avatar
michaelni committed
7717 7718
#define COUNT 8000
#define SIZE (COUNT*40)
diego's avatar
diego committed
7719
int main(void){
michaelni's avatar
michaelni committed
7720 7721 7722 7723 7724 7725 7726
    int i;
    uint8_t temp[SIZE];
    PutBitContext pb;
    GetBitContext gb;
//    int int_temp[10000];
    DSPContext dsp;
    AVCodecContext avctx;
7727

michaelni's avatar
michaelni committed
7728 7729
    dsputil_init(&dsp, &avctx);

7730
    init_put_bits(&pb, temp, SIZE);
michaelni's avatar
michaelni committed
7731 7732 7733 7734 7735 7736 7737
    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);
7738

michaelni's avatar
michaelni committed
7739 7740 7741
    init_get_bits(&gb, temp, 8*SIZE);
    for(i=0; i<COUNT; i++){
        int j, s;
7742

michaelni's avatar
michaelni committed
7743
        s= show_bits(&gb, 24);
7744

michaelni's avatar
michaelni committed
7745 7746 7747
        START_TIMER
        j= get_ue_golomb(&gb);
        if(j != i){
diego's avatar
diego committed
7748
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
michaelni's avatar
michaelni committed
7749 7750 7751 7752
//            return -1;
        }
        STOP_TIMER("get_ue_golomb");
    }
7753 7754


alex's avatar
10l  
alex committed
7755
    init_put_bits(&pb, temp, SIZE);
michaelni's avatar
michaelni committed
7756 7757 7758 7759 7760 7761 7762
    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);
7763

michaelni's avatar
michaelni committed
7764 7765 7766
    init_get_bits(&gb, temp, 8*SIZE);
    for(i=0; i<COUNT; i++){
        int j, s;
7767

michaelni's avatar
michaelni committed
7768
        s= show_bits(&gb, 24);
7769

michaelni's avatar
michaelni committed
7770 7771 7772
        START_TIMER
        j= get_se_golomb(&gb);
        if(j != i - COUNT/2){
diego's avatar
diego committed
7773
            printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
michaelni's avatar
michaelni committed
7774 7775 7776 7777 7778
//            return -1;
        }
        STOP_TIMER("get_se_golomb");
    }

7779
#if 0
michaelni's avatar
michaelni committed
7780
    printf("testing 4x4 (I)DCT\n");
7781

michaelni's avatar
michaelni committed
7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794
    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);
7795

michaelni's avatar
michaelni committed
7796 7797 7798 7799 7800 7801 7802 7803
        //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");
7804

7805
        s->dsp.h264_idct_add(ref, block, 4);
michaelni's avatar
michaelni committed
7806 7807 7808 7809
/*        for(j=0; j<16; j++){
            printf("%d ", ref[j]);
        }
        printf("\n");*/
7810

michaelni's avatar
michaelni committed
7811
        for(j=0; j<16; j++){
diego's avatar
diego committed
7812
            int diff= FFABS(src[j] - ref[j]);
7813

michaelni's avatar
michaelni committed
7814 7815 7816 7817 7818 7819 7820 7821 7822
            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;
7823

michaelni's avatar
michaelni committed
7824 7825
    }
    printf("Testing NAL layer\n");
7826

michaelni's avatar
michaelni committed
7827 7828 7829 7830
    uint8_t bitstream[COUNT];
    uint8_t nal[COUNT*2];
    H264Context h;
    memset(&h, 0, sizeof(H264Context));
7831

michaelni's avatar
michaelni committed
7832 7833 7834 7835 7836 7837 7838
    for(i=0; i<COUNT; i++){
        int zeros= i;
        int nal_length;
        int consumed;
        int out_length;
        uint8_t *out;
        int j;
7839

michaelni's avatar
michaelni committed
7840 7841 7842
        for(j=0; j<COUNT; j++){
            bitstream[j]= (random() % 255) + 1;
        }
7843

michaelni's avatar
michaelni committed
7844 7845 7846 7847 7848 7849 7850 7851
        for(j=0; j<zeros; j++){
            int pos= random() % COUNT;
            while(bitstream[pos] == 0){
                pos++;
                pos %= COUNT;
            }
            bitstream[pos]=0;
        }
7852

michaelni's avatar
michaelni committed
7853
        START_TIMER
7854

michaelni's avatar
michaelni committed
7855 7856 7857 7858 7859
        nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
        if(nal_length<0){
            printf("encoding failed\n");
            return -1;
        }
7860

michaelni's avatar
michaelni committed
7861 7862 7863
        out= decode_nal(&h, nal, &out_length, &consumed, nal_length);

        STOP_TIMER("NAL")
7864

michaelni's avatar
michaelni committed
7865 7866 7867 7868
        if(out_length != COUNT){
            printf("incorrect length %d %d\n", out_length, COUNT);
            return -1;
        }
7869

michaelni's avatar
michaelni committed
7870 7871 7872 7873
        if(consumed != nal_length){
            printf("incorrect consumed length %d %d\n", nal_length, consumed);
            return -1;
        }
7874

michaelni's avatar
michaelni committed
7875
        if(memcmp(bitstream, out, COUNT)){
diego's avatar
diego committed
7876
            printf("mismatch\n");
michaelni's avatar
michaelni committed
7877 7878 7879
            return -1;
        }
    }
7880
#endif
7881

michaelni's avatar
michaelni committed
7882
    printf("Testing RBSP\n");
7883 7884


michaelni's avatar
michaelni committed
7885 7886
    return 0;
}
7887
#endif /* TEST */
michaelni's avatar
michaelni committed
7888 7889


7890
static av_cold int decode_end(AVCodecContext *avctx)
michaelni's avatar
michaelni committed
7891 7892 7893
{
    H264Context *h = avctx->priv_data;
    MpegEncContext *s = &h->s;
7894
    int i;
7895

7896 7897
    av_freep(&h->rbsp_buffer[0]);
    av_freep(&h->rbsp_buffer[1]);
michaelni's avatar
michaelni committed
7898
    free_tables(h); //FIXME cleanup init stuff perhaps
7899 7900 7901 7902 7903 7904 7905

    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
7906 7907 7908
    MPV_common_end(s);

//    memset(h, 0, sizeof(H264Context));
7909

michaelni's avatar
michaelni committed
7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922
    return 0;
}


AVCodec h264_decoder = {
    "h264",
    CODEC_TYPE_VIDEO,
    CODEC_ID_H264,
    sizeof(H264Context),
    decode_init,
    NULL,
    decode_end,
    decode_frame,
7923
    /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY,
lorenm's avatar
lorenm committed
7924
    .flush= flush_dpb,
7925
    .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
michaelni's avatar
michaelni committed
7926 7927
};

michaelni's avatar
michaelni committed
7928
#include "svq3.c"