h264.h 56.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * 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
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
23
 * @file libavcodec/h264.h
24 25 26 27
 * H.264 / AVC / MPEG4 part10 codec.
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

28 29
#ifndef AVCODEC_H264_H
#define AVCODEC_H264_H
30

Måns Rullgård's avatar
Måns Rullgård committed
31
#include "libavutil/intreadwrite.h"
32 33 34
#include "dsputil.h"
#include "cabac.h"
#include "mpegvideo.h"
35
#include "h264pred.h"
36
#include "rectangle.h"
37 38

#define interlaced_dct interlaced_dct_is_a_bad_name
Diego Biurrun's avatar
Diego Biurrun committed
39
#define mb_intra mb_intra_is_not_initialized_see_mb_type
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#define LUMA_DC_BLOCK_INDEX   25
#define CHROMA_DC_BLOCK_INDEX 26

#define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
#define COEFF_TOKEN_VLC_BITS           8
#define TOTAL_ZEROS_VLC_BITS           9
#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
#define RUN_VLC_BITS                   3
#define RUN7_VLC_BITS                  6

#define MAX_SPS_COUNT 32
#define MAX_PPS_COUNT 256

#define MAX_MMCO_COUNT 66

56 57
#define MAX_DELAYED_PIC_COUNT 16

58 59 60 61
/* Compiling in interlaced support reduces the speed
 * of progressive decoding by about 2%. */
#define ALLOW_INTERLACE

62 63
#define ALLOW_NOCHROMA

64 65 66 67 68 69
/**
 * The maximum number of slices supported by the decoder.
 * must be a power of 2
 */
#define MAX_SLICES 16

70 71 72 73
#ifdef ALLOW_INTERLACE
#define MB_MBAFF h->mb_mbaff
#define MB_FIELD h->mb_field_decoding_flag
#define FRAME_MBAFF h->mb_aff_frame
Carl Eugen Hoyos's avatar
Carl Eugen Hoyos committed
74
#define FIELD_PICTURE (s->picture_structure != PICT_FRAME)
75 76 77 78
#else
#define MB_MBAFF 0
#define MB_FIELD 0
#define FRAME_MBAFF 0
79
#define FIELD_PICTURE 0
80 81 82
#undef  IS_INTERLACED
#define IS_INTERLACED(mb_type) 0
#endif
83
#define FIELD_OR_MBAFF_PICTURE (FRAME_MBAFF || FIELD_PICTURE)
84

85 86 87 88 89 90
#ifdef ALLOW_NOCHROMA
#define CHROMA h->sps.chroma_format_idc
#else
#define CHROMA 1
#endif

91 92 93 94
#ifndef CABAC
#define CABAC h->pps.cabac
#endif

95 96
#define EXTENDED_SAR          255

97 98 99 100 101
#define MB_TYPE_REF0       MB_TYPE_ACPRED //dirty but it fits in 16 bit
#define MB_TYPE_8x8DCT     0x01000000
#define IS_REF0(a)         ((a) & MB_TYPE_REF0)
#define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)

102 103 104 105 106 107 108
/**
 * Value of Picture.reference when Picture is not a reference picture, but
 * is held for delayed output.
 */
#define DELAYED_PIC_REF 4


109 110
/* NAL unit types */
enum {
111 112 113 114 115 116 117 118 119 120 121 122 123 124
    NAL_SLICE=1,
    NAL_DPA,
    NAL_DPB,
    NAL_DPC,
    NAL_IDR_SLICE,
    NAL_SEI,
    NAL_SPS,
    NAL_PPS,
    NAL_AUD,
    NAL_END_SEQUENCE,
    NAL_END_STREAM,
    NAL_FILLER_DATA,
    NAL_SPS_EXT,
    NAL_AUXILIARY_SLICE=19
125 126
};

127 128 129 130
/**
 * SEI message types
 */
typedef enum {
131
    SEI_BUFFERING_PERIOD             =  0, ///< buffering period (H.264, D.1.1)
132 133 134 135 136
    SEI_TYPE_PIC_TIMING              =  1, ///< picture timing
    SEI_TYPE_USER_DATA_UNREGISTERED  =  5, ///< unregistered user data
    SEI_TYPE_RECOVERY_POINT          =  6  ///< recovery point (frame # to decoder sync)
} SEI_Type;

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
/**
 * pic_struct in picture timing SEI message
 */
typedef enum {
    SEI_PIC_STRUCT_FRAME             = 0, ///<  0: %frame
    SEI_PIC_STRUCT_TOP_FIELD         = 1, ///<  1: top field
    SEI_PIC_STRUCT_BOTTOM_FIELD      = 2, ///<  2: bottom field
    SEI_PIC_STRUCT_TOP_BOTTOM        = 3, ///<  3: top field, bottom field, in that order
    SEI_PIC_STRUCT_BOTTOM_TOP        = 4, ///<  4: bottom field, top field, in that order
    SEI_PIC_STRUCT_TOP_BOTTOM_TOP    = 5, ///<  5: top field, bottom field, top field repeated, in that order
    SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM = 6, ///<  6: bottom field, top field, bottom field repeated, in that order
    SEI_PIC_STRUCT_FRAME_DOUBLING    = 7, ///<  7: %frame doubling
    SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
} SEI_PicStructType;

152 153 154 155 156 157 158
/**
 * Sequence parameter set
 */
typedef struct SPS{

    int profile_idc;
    int level_idc;
159
    int chroma_format_idc;
160 161 162 163 164 165 166 167 168 169
    int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
    int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
    int poc_type;                      ///< pic_order_cnt_type
    int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
    int delta_pic_order_always_zero_flag;
    int offset_for_non_ref_pic;
    int offset_for_top_to_bottom_field;
    int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
    int ref_frame_count;               ///< num_ref_frames
    int gaps_in_frame_num_allowed_flag;
170 171
    int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
    int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
172 173 174 175
    int frame_mbs_only_flag;
    int mb_aff;                        ///<mb_adaptive_frame_field_flag
    int direct_8x8_inference_flag;
    int crop;                   ///< frame_cropping_flag
176 177 178 179
    unsigned int crop_left;            ///< frame_cropping_rect_left_offset
    unsigned int crop_right;           ///< frame_cropping_rect_right_offset
    unsigned int crop_top;             ///< frame_cropping_rect_top_offset
    unsigned int crop_bottom;          ///< frame_cropping_rect_bottom_offset
180 181
    int vui_parameters_present_flag;
    AVRational sar;
182 183 184 185 186 187
    int video_signal_type_present_flag;
    int full_range;
    int colour_description_present_flag;
    enum AVColorPrimaries color_primaries;
    enum AVColorTransferCharacteristic color_trc;
    enum AVColorSpace colorspace;
188 189 190 191 192 193 194 195 196 197
    int timing_info_present_flag;
    uint32_t num_units_in_tick;
    uint32_t time_scale;
    int fixed_frame_rate_flag;
    short offset_for_ref_frame[256]; //FIXME dyn aloc?
    int bitstream_restriction_flag;
    int num_reorder_frames;
    int scaling_matrix_present;
    uint8_t scaling_matrix4[6][16];
    uint8_t scaling_matrix8[2][64];
198 199 200 201
    int nal_hrd_parameters_present_flag;
    int vcl_hrd_parameters_present_flag;
    int pic_struct_present_flag;
    int time_offset_length;
202
    int cpb_cnt;                       ///< See H.264 E.1.2
203
    int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 +1
204 205
    int cpb_removal_delay_length;      ///< cpb_removal_delay_length_minus1 + 1
    int dpb_output_delay_length;       ///< dpb_output_delay_length_minus1 + 1
206 207 208
    int bit_depth_luma;                ///< bit_depth_luma_minus8 + 8
    int bit_depth_chroma;              ///< bit_depth_chroma_minus8 + 8
    int residual_color_transform_flag; ///< residual_colour_transform_flag
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
}SPS;

/**
 * Picture parameter set
 */
typedef struct PPS{
    unsigned int sps_id;
    int cabac;                  ///< entropy_coding_mode_flag
    int pic_order_present;      ///< pic_order_present_flag
    int slice_group_count;      ///< num_slice_groups_minus1 + 1
    int mb_slice_group_map_type;
    unsigned int ref_count[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
    int weighted_pred;          ///< weighted_pred_flag
    int weighted_bipred_idc;
    int init_qp;                ///< pic_init_qp_minus26 + 26
    int init_qs;                ///< pic_init_qs_minus26 + 26
225
    int chroma_qp_index_offset[2];
226 227 228 229 230 231
    int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
    int constrained_intra_pred; ///< constrained_intra_pred_flag
    int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
    int transform_8x8_mode;     ///< transform_8x8_mode_flag
    uint8_t scaling_matrix4[6][16];
    uint8_t scaling_matrix8[2][64];
232
    uint8_t chroma_qp_table[2][64];  ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
233
    int chroma_qp_diff;
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
}PPS;

/**
 * Memory management control operation opcode.
 */
typedef enum MMCOOpcode{
    MMCO_END=0,
    MMCO_SHORT2UNUSED,
    MMCO_LONG2UNUSED,
    MMCO_SHORT2LONG,
    MMCO_SET_MAX_LONG,
    MMCO_RESET,
    MMCO_LONG,
} MMCOOpcode;

/**
 * Memory management control operation.
 */
typedef struct MMCO{
    MMCOOpcode opcode;
254 255
    int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
    int long_arg;       ///< index, pic_num, or num long refs depending on opcode
256 257 258 259 260 261 262 263 264
} MMCO;

/**
 * H264Context
 */
typedef struct H264Context{
    MpegEncContext s;
    int nal_ref_idc;
    int nal_unit_type;
265 266
    uint8_t *rbsp_buffer[2];
    unsigned int rbsp_buffer_size[2];
267 268 269 270 271 272 273 274

    /**
      * Used to parse AVC variant of h264
      */
    int is_avc; ///< this flag is != 0 if codec is avc1
    int got_avcC; ///< flag used to parse avcC data only once
    int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)

275
    int chroma_qp[2]; //QPc
276

277 278
    int qp_thresh;      ///< QP threshold to skip loopfilter

279 280 281 282 283 284 285
    int prev_mb_skipped;
    int next_mb_skipped;

    //prediction stuff
    int chroma_pred_mode;
    int intra16x16_pred_mode;

286
    int topleft_mb_xy;
287
    int top_mb_xy;
288
    int topright_mb_xy;
289 290
    int left_mb_xy[2];

291
    int topleft_type;
292
    int top_type;
293
    int topright_type;
294 295
    int left_type[2];

296 297 298
    const uint8_t * left_block;
    int topleft_partition;

299 300
    int8_t intra4x4_pred_mode_cache[5*8];
    int8_t (*intra4x4_pred_mode)[8];
301
    H264PredContext hpc;
302 303 304 305 306 307 308 309 310 311 312
    unsigned int topleft_samples_available;
    unsigned int top_samples_available;
    unsigned int topright_samples_available;
    unsigned int left_samples_available;
    uint8_t (*top_borders[2])[16+2*8];
    uint8_t left_border[2*(17+2*9)];

    /**
     * non zero coeff count cache.
     * is 64 if not available.
     */
313
    DECLARE_ALIGNED_8(uint8_t, non_zero_count_cache)[6*8];
314 315 316 317 318 319 320

    /*
    .UU.YYYY
    .UU.YYYY
    .vv.YYYY
    .VV.YYYY
    */
321
    uint8_t (*non_zero_count)[32];
322 323 324 325

    /**
     * Motion vector cache.
     */
326
    DECLARE_ALIGNED_16(int16_t, mv_cache)[2][5*8][2];
327
    DECLARE_ALIGNED_8(int8_t, ref_cache)[2][5*8];
328 329 330 331 332 333 334 335 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 361 362 363
#define LIST_NOT_USED -1 //FIXME rename?
#define PART_NOT_AVAILABLE -2

    /**
     * is 1 if the specific list MV&references are set to 0,0,-2.
     */
    int mv_cache_clean[2];

    /**
     * number of neighbors (top and/or left) that used 8x8 dct
     */
    int neighbor_transform_size;

    /**
     * block_offset[ 0..23] for frame macroblocks
     * block_offset[24..47] for field macroblocks
     */
    int block_offset[2*(16+8)];

    uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
    uint32_t *mb2b8_xy;
    int b_stride; //FIXME use s->b4_stride
    int b8_stride;

    int mb_linesize;   ///< may be equal to s->linesize or s->linesize*2, for mbaff
    int mb_uvlinesize;

    int emu_edge_width;
    int emu_edge_height;

    int halfpel_flag;
    int thirdpel_flag;

    int unknown_svq3_flag;
    int next_slice_index;

364
    SPS *sps_buffers[MAX_SPS_COUNT];
365 366
    SPS sps; ///< current sps

367
    PPS *pps_buffers[MAX_PPS_COUNT];
368 369 370 371 372 373 374 375 376 377 378 379
    /**
     * current pps
     */
    PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?

    uint32_t dequant4_buffer[6][52][16];
    uint32_t dequant8_buffer[2][52][64];
    uint32_t (*dequant4_coeff[6])[16];
    uint32_t (*dequant8_coeff[2])[64];
    int dequant_coeff_pps;     ///< reinit tables when pps changes

    int slice_num;
380 381
    uint16_t *slice_table_base;
    uint16_t *slice_table;     ///< slice_table_base + 2*mb_stride + 1
382
    int slice_type;
383
    int slice_type_nos;        ///< S free slice type (SI/SP are remapped to I/P)
384 385 386 387 388 389 390
    int slice_type_fixed;

    //interlacing specific flags
    int mb_aff_frame;
    int mb_field_decoding_flag;
    int mb_mbaff;              ///< mb_aff_frame && mb_field_decoding_flag

391
    DECLARE_ALIGNED_8(uint16_t, sub_mb_type)[4];
392 393 394 395 396 397 398 399 400 401 402 403 404 405

    //POC stuff
    int poc_lsb;
    int poc_msb;
    int delta_poc_bottom;
    int delta_poc[2];
    int frame_num;
    int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
    int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
    int frame_num_offset;         ///< for POC type 2
    int prev_frame_num_offset;    ///< for POC type 2
    int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2

    /**
406
     * frame_num for frames or 2*frame_num+1 for field pics.
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433
     */
    int curr_pic_num;

    /**
     * max_frame_num or 2*max_frame_num for field pics.
     */
    int max_pic_num;

    //Weighted pred stuff
    int use_weight;
    int use_weight_chroma;
    int luma_log2_weight_denom;
    int chroma_log2_weight_denom;
    int luma_weight[2][48];
    int luma_offset[2][48];
    int chroma_weight[2][48][2];
    int chroma_offset[2][48][2];
    int implicit_weight[48][48];

    //deblock
    int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0
    int slice_alpha_c0_offset;
    int slice_beta_offset;

    int redundant_pic_count;

    int direct_spatial_mv_pred;
434 435
    int col_parity;
    int col_fieldoff;
436
    int dist_scale_factor[16];
437
    int dist_scale_factor_field[2][32];
438 439
    int map_col_to_list0[2][16+32];
    int map_col_to_list0_field[2][2][16+32];
440 441 442 443 444 445

    /**
     * num_ref_idx_l0/1_active_minus1 + 1
     */
    unsigned int ref_count[2];   ///< counts frames or fields, depending on current mb mode
    unsigned int list_count;
446
    uint8_t *list_counts;            ///< Array of list_count per MB specifying the slice type
447 448
    Picture *short_ref[32];
    Picture *long_ref[32];
449 450 451 452
    Picture default_ref_list[2][32]; ///< base reference list for all slices of a coded picture
    Picture ref_list[2][48];         /**< 0..15: frame refs, 16..47: mbaff field refs.
                                          Reordered version of default_ref_list
                                          according to picture reordering in slice header */
453
    int ref2frm[MAX_SLICES][2][64];  ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
454
    Picture *delayed_pic[MAX_DELAYED_PIC_COUNT+2]; //FIXME size?
455
    int outputed_poc;
456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

    /**
     * memory management control operations buffer.
     */
    MMCO mmco[MAX_MMCO_COUNT];
    int mmco_index;

    int long_ref_count;  ///< number of actual long term references
    int short_ref_count; ///< number of actual short term references

    //data partitioning
    GetBitContext intra_gb;
    GetBitContext inter_gb;
    GetBitContext *intra_gb_ptr;
    GetBitContext *inter_gb_ptr;

472
    DECLARE_ALIGNED_16(DCTELEM, mb)[16*24];
Diego Biurrun's avatar
Diego Biurrun committed
473
    DCTELEM mb_padding[256];        ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either check that i is not too large or ensure that there is some unused stuff after mb
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490

    /**
     * Cabac
     */
    CABACContext cabac;
    uint8_t      cabac_state[460];
    int          cabac_init_idc;

    /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
    uint16_t     *cbp_table;
    int cbp;
    int top_cbp;
    int left_cbp;
    /* chroma_pred_mode for i4x4 or i16x16, else 0 */
    uint8_t     *chroma_pred_mode_table;
    int         last_qscale_diff;
    int16_t     (*mvd_table[2])[2];
491
    DECLARE_ALIGNED_16(int16_t, mvd_cache)[2][5*8][2];
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
    uint8_t     *direct_table;
    uint8_t     direct_cache[5*8];

    uint8_t zigzag_scan[16];
    uint8_t zigzag_scan8x8[64];
    uint8_t zigzag_scan8x8_cavlc[64];
    uint8_t field_scan[16];
    uint8_t field_scan8x8[64];
    uint8_t field_scan8x8_cavlc[64];
    const uint8_t *zigzag_scan_q0;
    const uint8_t *zigzag_scan8x8_q0;
    const uint8_t *zigzag_scan8x8_cavlc_q0;
    const uint8_t *field_scan_q0;
    const uint8_t *field_scan8x8_q0;
    const uint8_t *field_scan8x8_cavlc_q0;

    int x264_build;
509 510 511 512 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

    /**
     * @defgroup multithreading Members for slice based multithreading
     * @{
     */
    struct H264Context *thread_context[MAX_THREADS];

    /**
     * current slice number, used to initalize slice_num of each thread/context
     */
    int current_slice;

    /**
     * Max number of threads / contexts.
     * This is equal to AVCodecContext.thread_count unless
     * multithreaded decoding is impossible, in which case it is
     * reduced to 1.
     */
    int max_contexts;

    /**
     *  1 if the single thread fallback warning has already been
     *  displayed, 0 otherwise.
     */
    int single_decode_warning;

    int last_slice_type;
    /** @} */

538 539
    int mb_xy;

540
    uint32_t svq3_watermark_key;
541 542 543 544 545

    /**
     * pic_struct in picture timing SEI message
     */
    SEI_PicStructType sei_pic_struct;
546

547
    /**
548 549 550 551 552 553 554 555
     * Complement sei_pic_struct
     * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
     * However, soft telecined frames may have these values.
     * This is used in an attempt to flag soft telecine progressive.
     */
    int prev_interlaced_frame;

    /**
556 557 558 559 560 561
     * Bit set of clock types for fields/frames in picture timing SEI message.
     * For each found ct_type, appropriate bit is set (e.g., bit 1 for
     * interlaced).
     */
    int sei_ct_type;

562 563 564 565 566
    /**
     * dpb_output_delay in picture timing SEI message, see H.264 C.2.2
     */
    int sei_dpb_output_delay;

567 568 569 570 571
    /**
     * cpb_removal_delay in picture timing SEI message, see H.264 C.1.2
     */
    int sei_cpb_removal_delay;

572 573 574 575 576 577 578 579 580
    /**
     * recovery_frame_cnt from SEI message
     *
     * Set to -1 if no recovery point SEI message found or to number of frames
     * before playback synchronizes. Frames having recovery point are key
     * frames.
     */
    int sei_recovery_frame_cnt;

581
    int is_complex;
582 583 584

    int luma_weight_flag[2];   ///< 7.4.3.2 luma_weight_lX_flag
    int chroma_weight_flag[2]; ///< 7.4.3.2 chroma_weight_lX_flag
585 586 587 588

    // Timestamp stuff
    int sei_buffering_period_present;  ///< Buffering period SEI flag
    int initial_cpb_removal_delay[32]; ///< Initial timestamps for CPBs
589 590
}H264Context;

591 592 593

extern const uint8_t ff_h264_chroma_qp[52];

594 595 596
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);

void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
597

598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
/**
 * Decode SEI
 */
int ff_h264_decode_sei(H264Context *h);

/**
 * Decode SPS
 */
int ff_h264_decode_seq_parameter_set(H264Context *h);

/**
 * Decode PPS
 */
int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length);

/**
 * Decodes a network abstraction layer unit.
 * @param consumed is the number of bytes used as input
 * @param length is the length of the array
 * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
 * @returns decoded bytes, might be src+1 if no escapes
 */
const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length);

/**
 * identifies the exact end of the bitstream
 * @return the length of the trailing, or 0 if damaged
 */
int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src);

628 629 630
/**
 * frees any data that may have been allocated in the H264 context like SPS, PPS etc.
 */
631
av_cold void ff_h264_free_context(H264Context *h);
632

633 634 635
/**
 * reconstructs bitstream slice_type.
 */
636
int ff_h264_get_slice_type(const H264Context *h);
637

638 639 640 641 642 643
/**
 * allocates tables.
 * needs width/height
 */
int ff_h264_alloc_tables(H264Context *h);

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
/**
 * fills the default_ref_list.
 */
int ff_h264_fill_default_ref_list(H264Context *h);

int ff_h264_decode_ref_pic_list_reordering(H264Context *h);
void ff_h264_fill_mbaff_ref_list(H264Context *h);
void ff_h264_remove_all_refs(H264Context *h);

/**
 * Executes the reference picture marking (memory management control operations).
 */
int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count);

int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb);


661 662 663 664 665
/**
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 */
int ff_h264_check_intra4x4_pred_mode(H264Context *h);

666 667 668 669 670 671 672 673 674 675
/**
 * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 */
int ff_h264_check_intra_pred_mode(H264Context *h, int mode);

void ff_h264_write_back_intra_pred_mode(H264Context *h);
void ff_h264_hl_decode_mb(H264Context *h);
int ff_h264_frame_start(H264Context *h);
av_cold int ff_h264_decode_init(AVCodecContext *avctx);
av_cold int ff_h264_decode_end(AVCodecContext *avctx);
676 677 678 679 680 681 682
av_cold void ff_h264_decode_init_vlc(void);

/**
 * decodes a macroblock
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
 */
int ff_h264_decode_mb_cavlc(H264Context *h);
683

684 685 686 687 688 689 690 691
/**
 * decodes a CABAC coded macroblock
 * @returns 0 if OK, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
 */
int ff_h264_decode_mb_cabac(H264Context *h);

void ff_h264_init_cabac_states(H264Context *h);

692 693 694 695
void ff_h264_direct_dist_scale_factor(H264Context * const h);
void ff_h264_direct_ref_list_init(H264Context * const h);
void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type);

696 697 698
void ff_h264_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);
void ff_h264_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);

699 700 701 702 703 704 705 706
/**
 * Reset SEI values at the beginning of the frame.
 *
 * @param h H.264 context.
 */
void ff_h264_reset_sei(H264Context *h);


707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
/*
o-o o-o
 / / /
o-o o-o
 ,---'
o-o o-o
 / / /
o-o o-o
*/
//This table must be here because scan8[constant] must be known at compiletime
static const uint8_t scan8[16 + 2*4]={
 4+1*8, 5+1*8, 4+2*8, 5+2*8,
 6+1*8, 7+1*8, 6+2*8, 7+2*8,
 4+3*8, 5+3*8, 4+4*8, 5+4*8,
 6+3*8, 7+3*8, 6+4*8, 7+4*8,
 1+1*8, 2+1*8,
 1+2*8, 2+2*8,
 1+4*8, 2+4*8,
 1+5*8, 2+5*8,
};

static av_always_inline uint32_t pack16to32(int a, int b){
#if HAVE_BIGENDIAN
   return (b&0xFFFF) + (a<<16);
#else
   return (a&0xFFFF) + (b<<16);
#endif
}

736 737 738 739 740 741 742
/**
 * gets the chroma qp.
 */
static inline int get_chroma_qp(H264Context *h, int t, int qscale){
    return h->pps.chroma_qp_table[t][qscale];
}

743 744
static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my);

745
static void fill_decode_neighbors(H264Context *h, int mb_type){
746 747 748
    MpegEncContext * const s = &h->s;
    const int mb_xy= h->mb_xy;
    int topleft_xy, top_xy, topright_xy, left_xy[2];
749 750 751 752 753
    static const uint8_t left_block_options[4][16]={
        {0,1,2,3,7,10,8,11,7+0*8, 7+1*8, 7+2*8, 7+3*8, 2+0*8, 2+3*8, 2+1*8, 2+2*8},
        {2,2,3,3,8,11,8,11,7+2*8, 7+2*8, 7+3*8, 7+3*8, 2+1*8, 2+2*8, 2+1*8, 2+2*8},
        {0,0,1,1,7,10,7,10,7+0*8, 7+0*8, 7+1*8, 7+1*8, 2+0*8, 2+3*8, 2+0*8, 2+3*8},
        {0,2,0,2,7,10,7,10,7+0*8, 7+2*8, 7+0*8, 7+2*8, 2+0*8, 2+3*8, 2+0*8, 2+3*8}
754 755
    };

756 757
    h->topleft_partition= -1;

758
    top_xy     = mb_xy  - (s->mb_stride << MB_FIELD);
759 760 761 762 763 764 765

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

    topleft_xy = top_xy - 1;
    topright_xy= top_xy + 1;
    left_xy[1] = left_xy[0] = mb_xy-1;
766
    h->left_block = left_block_options[0];
767
    if(FRAME_MBAFF){
768
        const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
769
        const int curr_mb_field_flag     = IS_INTERLACED(mb_type);
770 771 772 773 774
        if(s->mb_y&1){
            if (left_mb_field_flag != curr_mb_field_flag) {
                left_xy[1] = left_xy[0] = mb_xy - s->mb_stride - 1;
                if (curr_mb_field_flag) {
                    left_xy[1] += s->mb_stride;
775
                    h->left_block = left_block_options[3];
776 777 778
                } else {
                    topleft_xy += s->mb_stride;
                    // take top left mv from the middle of the mb, as opposed to all other modes which use the bottom right partition
779 780
                    h->topleft_partition = 0;
                    h->left_block = left_block_options[1];
781 782 783 784 785 786 787 788 789 790 791 792
                }
            }
        }else{
            if(curr_mb_field_flag){
                topleft_xy  += s->mb_stride & (((s->current_picture.mb_type[top_xy - 1]>>7)&1)-1);
                topright_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy + 1]>>7)&1)-1);
                top_xy      += s->mb_stride & (((s->current_picture.mb_type[top_xy    ]>>7)&1)-1);
            }
            if (left_mb_field_flag != curr_mb_field_flag) {
                left_xy[1] = left_xy[0] = mb_xy - 1;
                if (curr_mb_field_flag) {
                    left_xy[1] += s->mb_stride;
793
                    h->left_block = left_block_options[3];
794
                } else {
795
                    h->left_block = left_block_options[2];
796
                }
797 798 799 800
            }
        }
    }

801 802 803
    h->topleft_mb_xy = topleft_xy;
    h->top_mb_xy     = top_xy;
    h->topright_mb_xy= topright_xy;
804 805
    h->left_mb_xy[0] = left_xy[0];
    h->left_mb_xy[1] = left_xy[1];
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
    //FIXME do we need all in the context?
    h->topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
    h->top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;
    h->topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
    h->left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
    h->left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
}

static void fill_decode_caches(H264Context *h, int mb_type){
    MpegEncContext * const s = &h->s;
    int topleft_xy, top_xy, topright_xy, left_xy[2];
    int topleft_type, top_type, topright_type, left_type[2];
    const uint8_t * left_block= h->left_block;
    int i;

    topleft_xy   = h->topleft_mb_xy ;
    top_xy       = h->top_mb_xy     ;
    topright_xy  = h->topright_mb_xy;
    left_xy[0]   = h->left_mb_xy[0] ;
    left_xy[1]   = h->left_mb_xy[1] ;
    topleft_type = h->topleft_type  ;
    top_type     = h->top_type      ;
    topright_type= h->topright_type ;
    left_type[0] = h->left_type[0]  ;
    left_type[1] = h->left_type[1]  ;
831

832
    if(!IS_SKIP(mb_type)){
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
        if(IS_INTRA(mb_type)){
            int type_mask= h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
            h->topleft_samples_available=
            h->top_samples_available=
            h->left_samples_available= 0xFFFF;
            h->topright_samples_available= 0xEEEA;

            if(!(top_type & type_mask)){
                h->topleft_samples_available= 0xB3FF;
                h->top_samples_available= 0x33FF;
                h->topright_samples_available= 0x26EA;
            }
            if(IS_INTERLACED(mb_type) != IS_INTERLACED(left_type[0])){
                if(IS_INTERLACED(mb_type)){
                    if(!(left_type[0] & type_mask)){
                        h->topleft_samples_available&= 0xDFFF;
                        h->left_samples_available&= 0x5FFF;
                    }
                    if(!(left_type[1] & type_mask)){
                        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]);
                    if(!((left_typei & type_mask) && (left_type[0] & type_mask))){
                        h->topleft_samples_available&= 0xDF5F;
                        h->left_samples_available&= 0x5F5F;
                    }
863 864
                }
            }else{
865
                if(!(left_type[0] & type_mask)){
866 867 868 869 870
                    h->topleft_samples_available&= 0xDF5F;
                    h->left_samples_available&= 0x5F5F;
                }
            }

871 872
            if(!(topleft_type & type_mask))
                h->topleft_samples_available&= 0x7FFF;
873

874 875
            if(!(topright_type & type_mask))
                h->topright_samples_available&= 0xFBFF;
876

877 878 879 880 881 882
            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];
883 884
                }else{
                    int pred;
885
                    if(!(top_type & type_mask))
886 887 888 889
                        pred= -1;
                    else{
                        pred= 2;
                    }
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
                    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;
                        if(!(left_type[i] & type_mask))
                            pred= -1;
                        else{
                            pred= 2;
                        }
                        h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
                        h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
                    }
909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
                }
            }
        }


/*
0 . T T. T T T T
1 L . .L . . . .
2 L . .L . . . .
3 . T TL . . . .
4 L . .L . . . .
5 L . .. . . . .
*/
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
    if(top_type){
Måns Rullgård's avatar
Måns Rullgård committed
924
        AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]);
925 926
            h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][1+1*8];
            h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][2+1*8];
927

928 929
            h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][1+2*8];
            h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][2+2*8];
930
    }else {
931 932
            h->non_zero_count_cache[1+8*0]=
            h->non_zero_count_cache[2+8*0]=
933

934 935
            h->non_zero_count_cache[1+8*3]=
            h->non_zero_count_cache[2+8*3]=
Måns Rullgård's avatar
Måns Rullgård committed
936
            AV_WN32A(&h->non_zero_count_cache[4+8*0], CABAC && !IS_INTRA(mb_type) ? 0 : 0x40404040);
937 938 939 940
    }

    for (i=0; i<2; i++) {
        if(left_type[i]){
941 942
            h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+0+2*i]];
            h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[8+1+2*i]];
943 944
                h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[8+4+2*i]];
                h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[8+5+2*i]];
945
        }else{
946 947 948 949
                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]=
                h->non_zero_count_cache[0+8*4 +   8*i]= CABAC && !IS_INTRA(mb_type) ? 0 : 64;
950 951 952
        }
    }

953
    if( CABAC ) {
954 955 956 957
        // top_cbp
        if(top_type) {
            h->top_cbp = h->cbp_table[top_xy];
        } else if(IS_INTRA(mb_type)) {
958
            h->top_cbp = 0x1CF;
959
        } else {
960
            h->top_cbp = 0x00F;
961 962 963 964 965
        }
        // left_cbp
        if (left_type[0]) {
            h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
        } else if(IS_INTRA(mb_type)) {
966
            h->left_cbp = 0x1CF;
967
        } else {
968
            h->left_cbp = 0x00F;
969 970 971 972 973 974 975 976
        }
        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;
        }
    }
977
    }
978 979

#if 1
980
    if(IS_INTER(mb_type) || (IS_DIRECT(mb_type) && h->direct_spatial_mv_pred)){
981 982
        int list;
        for(list=0; list<h->list_count; list++){
983
            if(!USES_LIST(mb_type, list)){
984 985 986 987 988 989 990
                /*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;
                }*/
                continue;
            }
991 992
            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));

993 994 995 996 997
            h->mv_cache_clean[list]= 0;

            if(USES_LIST(top_type, list)){
                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;
998
                AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
999 1000 1001 1002
                    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];
1003
            }else{
1004
                AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
Måns Rullgård's avatar
Måns Rullgård committed
1005
                AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101);
1006 1007 1008 1009 1010 1011 1012
            }

            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;
Måns Rullgård's avatar
Måns Rullgård committed
1013 1014
                    AV_COPY32(h->mv_cache[list][cache_idx  ], s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0+i*2]]);
                    AV_COPY32(h->mv_cache[list][cache_idx+8], s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1+i*2]]);
1015 1016
                        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)];
1017
                }else{
Måns Rullgård's avatar
Måns Rullgård committed
1018 1019
                    AV_ZERO32(h->mv_cache [list][cache_idx  ]);
                    AV_ZERO32(h->mv_cache [list][cache_idx+8]);
1020
                    h->ref_cache[list][cache_idx  ]=
1021
                    h->ref_cache[list][cache_idx+8]= (left_type[i]) ? LIST_NOT_USED : PART_NOT_AVAILABLE;
1022 1023 1024 1025
                }
            }

            if(USES_LIST(topleft_type, list)){
1026 1027
                const int b_xy = h->mb2b_xy [topleft_xy] + 3 + h->b_stride + (h->topleft_partition & 2*h->b_stride);
                const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + (h->topleft_partition & h->b8_stride);
Måns Rullgård's avatar
Måns Rullgård committed
1028
                AV_COPY32(h->mv_cache[list][scan8[0] - 1 - 1*8], s->current_picture.motion_val[list][b_xy]);
1029 1030
                h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
            }else{
Måns Rullgård's avatar
Måns Rullgård committed
1031
                AV_ZERO32(h->mv_cache[list][scan8[0] - 1 - 1*8]);
1032 1033 1034 1035 1036 1037
                h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
            }

            if(USES_LIST(topright_type, list)){
                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;
Måns Rullgård's avatar
Måns Rullgård committed
1038
                AV_COPY32(h->mv_cache[list][scan8[0] + 4 - 1*8], s->current_picture.motion_val[list][b_xy]);
1039 1040
                h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
            }else{
Måns Rullgård's avatar
Måns Rullgård committed
1041
                AV_ZERO32(h->mv_cache [list][scan8[0] + 4 - 1*8]);
1042 1043 1044
                h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
            }

1045
            if((mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2)) && !FRAME_MBAFF)
1046 1047
                continue;

1048
            if(!(mb_type&(MB_TYPE_SKIP|MB_TYPE_DIRECT2))) {
1049 1050 1051 1052 1053
            h->ref_cache[list][scan8[5 ]+1] =
            h->ref_cache[list][scan8[7 ]+1] =
            h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)
            h->ref_cache[list][scan8[4 ]] =
            h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
Måns Rullgård's avatar
Måns Rullgård committed
1054 1055 1056 1057 1058
            AV_ZERO32(h->mv_cache [list][scan8[5 ]+1]);
            AV_ZERO32(h->mv_cache [list][scan8[7 ]+1]);
            AV_ZERO32(h->mv_cache [list][scan8[13]+1]); //FIXME remove past 3 (init somewhere else)
            AV_ZERO32(h->mv_cache [list][scan8[4 ]]);
            AV_ZERO32(h->mv_cache [list][scan8[12]]);
1059

1060
            if( CABAC ) {
1061 1062 1063
                /* XXX beurk, Load mvd */
                if(USES_LIST(top_type, list)){
                    const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
1064
                    AV_COPY128(h->mvd_cache[list][scan8[0] + 0 - 1*8], h->mvd_table[list][b_xy + 0]);
1065
                }else{
1066
                    AV_ZERO128(h->mvd_cache[list][scan8[0] + 0 - 1*8]);
1067 1068 1069
                }
                if(USES_LIST(left_type[0], list)){
                    const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
Måns Rullgård's avatar
Måns Rullgård committed
1070 1071
                    AV_COPY32(h->mvd_cache[list][scan8[0] - 1 + 0*8], h->mvd_table[list][b_xy + h->b_stride*left_block[0]]);
                    AV_COPY32(h->mvd_cache[list][scan8[0] - 1 + 1*8], h->mvd_table[list][b_xy + h->b_stride*left_block[1]]);
1072
                }else{
Måns Rullgård's avatar
Måns Rullgård committed
1073 1074
                    AV_ZERO32(h->mvd_cache [list][scan8[0] - 1 + 0*8]);
                    AV_ZERO32(h->mvd_cache [list][scan8[0] - 1 + 1*8]);
1075 1076 1077
                }
                if(USES_LIST(left_type[1], list)){
                    const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
Måns Rullgård's avatar
Måns Rullgård committed
1078 1079
                    AV_COPY32(h->mvd_cache[list][scan8[0] - 1 + 2*8], h->mvd_table[list][b_xy + h->b_stride*left_block[2]]);
                    AV_COPY32(h->mvd_cache[list][scan8[0] - 1 + 3*8], h->mvd_table[list][b_xy + h->b_stride*left_block[3]]);
1080
                }else{
Måns Rullgård's avatar
Måns Rullgård committed
1081 1082
                    AV_ZERO32(h->mvd_cache [list][scan8[0] - 1 + 2*8]);
                    AV_ZERO32(h->mvd_cache [list][scan8[0] - 1 + 3*8]);
1083
                }
Måns Rullgård's avatar
Måns Rullgård committed
1084 1085 1086 1087 1088
                AV_ZERO32(h->mvd_cache [list][scan8[5 ]+1]);
                AV_ZERO32(h->mvd_cache [list][scan8[7 ]+1]);
                AV_ZERO32(h->mvd_cache [list][scan8[13]+1]); //FIXME remove past 3 (init somewhere else)
                AV_ZERO32(h->mvd_cache [list][scan8[4 ]]);
                AV_ZERO32(h->mvd_cache [list][scan8[12]]);
1089 1090

                if(h->slice_type_nos == FF_B_TYPE){
1091
                    fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, MB_TYPE_16x16>>1, 1);
1092 1093

                    if(IS_DIRECT(top_type)){
Måns Rullgård's avatar
Måns Rullgård committed
1094
                        AV_WN32A(&h->direct_cache[scan8[0] - 1*8], 0x01010101*(MB_TYPE_DIRECT2>>1));
1095 1096 1097 1098 1099
                    }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{
Måns Rullgård's avatar
Måns Rullgård committed
1100
                        AV_WN32A(&h->direct_cache[scan8[0] - 1*8], 0x01010101*(MB_TYPE_16x16>>1));
1101 1102 1103
                    }

                    if(IS_DIRECT(left_type[0]))
1104
                        h->direct_cache[scan8[0] - 1 + 0*8]= MB_TYPE_DIRECT2>>1;
1105 1106 1107
                    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
1108
                        h->direct_cache[scan8[0] - 1 + 0*8]= MB_TYPE_16x16>>1;
1109 1110

                    if(IS_DIRECT(left_type[1]))
1111
                        h->direct_cache[scan8[0] - 1 + 2*8]= MB_TYPE_DIRECT2>>1;
1112 1113 1114
                    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
1115
                        h->direct_cache[scan8[0] - 1 + 2*8]= MB_TYPE_16x16>>1;