git.sesse.net Git - ffmpeg/blob - libavcodec/h264.c

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 /**
  22  * @file h264.c
  23  * H.264 / AVC / MPEG4 part10 codec.
  24  * @author Michael Niedermayer <michaelni@gmx.at>
  25  */
  26
  27 #include "common.h"
  28 #include "dsputil.h"
  29 #include "avcodec.h"
  30 #include "mpegvideo.h"
  31 #include "h264data.h"
  32 #include "golomb.h"
  33
  34 #include "cabac.h"
  35
  36 #undef NDEBUG
  37 #include <assert.h>
  38
  39 #define interlaced_dct interlaced_dct_is_a_bad_name
  40 #define mb_intra mb_intra_isnt_initalized_see_mb_type
  41
  42 #define LUMA_DC_BLOCK_INDEX   25
  43 #define CHROMA_DC_BLOCK_INDEX 26
  44
  45 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
  46 #define COEFF_TOKEN_VLC_BITS           8
  47 #define TOTAL_ZEROS_VLC_BITS           9
  48 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
  49 #define RUN_VLC_BITS                   3
  50 #define RUN7_VLC_BITS                  6
  51
  52 #define MAX_SPS_COUNT 32
  53 #define MAX_PPS_COUNT 256
  54
  55 #define MAX_MMCO_COUNT 66
  56
  57 /**
  58  * Sequence parameter set
  59  */
  60 typedef struct SPS{
  61
  62     int profile_idc;
  63     int level_idc;
  64     int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
  65     int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
  66     int poc_type;                      ///< pic_order_cnt_type
  67     int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
  68     int delta_pic_order_always_zero_flag;
  69     int offset_for_non_ref_pic;
  70     int offset_for_top_to_bottom_field;
  71     int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
  72     int ref_frame_count;               ///< num_ref_frames
  73     int gaps_in_frame_num_allowed_flag;
  74     int mb_width;                      ///< frame_width_in_mbs_minus1 + 1
  75     int mb_height;                     ///< frame_height_in_mbs_minus1 + 1
  76     int frame_mbs_only_flag;
  77     int mb_aff;                        ///<mb_adaptive_frame_field_flag
  78     int direct_8x8_inference_flag;
  79     int crop;                   ///< frame_cropping_flag
  80     int crop_left;              ///< frame_cropping_rect_left_offset
  81     int crop_right;             ///< frame_cropping_rect_right_offset
  82     int crop_top;               ///< frame_cropping_rect_top_offset
  83     int crop_bottom;            ///< frame_cropping_rect_bottom_offset
  84     int vui_parameters_present_flag;
  85     AVRational sar;
  86     int timing_info_present_flag;
  87     uint32_t num_units_in_tick;
  88     uint32_t time_scale;
  89     int fixed_frame_rate_flag;
  90     short offset_for_ref_frame[256]; //FIXME dyn aloc?
  91     int bitstream_restriction_flag;
  92     int num_reorder_frames;
  93     int scaling_matrix_present;
  94     uint8_t scaling_matrix4[6][16];
  95     uint8_t scaling_matrix8[2][64];
  96 }SPS;
  97
  98 /**
  99  * Picture parameter set
 100  */
 101 typedef struct PPS{
 102     int sps_id;
 103     int cabac;                  ///< entropy_coding_mode_flag
 104     int pic_order_present;      ///< pic_order_present_flag
 105     int slice_group_count;      ///< num_slice_groups_minus1 + 1
 106     int mb_slice_group_map_type;
 107     int ref_count[2];           ///< num_ref_idx_l0/1_active_minus1 + 1
 108     int weighted_pred;          ///< weighted_pred_flag
 109     int weighted_bipred_idc;
 110     int init_qp;                ///< pic_init_qp_minus26 + 26
 111     int init_qs;                ///< pic_init_qs_minus26 + 26
 112     int chroma_qp_index_offset;
 113     int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
 114     int constrained_intra_pred; ///< constrained_intra_pred_flag
 115     int redundant_pic_cnt_present; ///< redundant_pic_cnt_present_flag
 116     int transform_8x8_mode;     ///< transform_8x8_mode_flag
 117     uint8_t scaling_matrix4[6][16];
 118     uint8_t scaling_matrix8[2][64];
 119 }PPS;
 120
 121 /**
 122  * Memory management control operation opcode.
 123  */
 124 typedef enum MMCOOpcode{
 125     MMCO_END=0,
 126     MMCO_SHORT2UNUSED,
 127     MMCO_LONG2UNUSED,
 128     MMCO_SHORT2LONG,
 129     MMCO_SET_MAX_LONG,
 130     MMCO_RESET,
 131     MMCO_LONG,
 132 } MMCOOpcode;
 133
 134 /**
 135  * Memory management control operation.
 136  */
 137 typedef struct MMCO{
 138     MMCOOpcode opcode;
 139     int short_frame_num;
 140     int long_index;
 141 } MMCO;
 142
 143 /**
 144  * H264Context
 145  */
 146 typedef struct H264Context{
 147     MpegEncContext s;
 148     int nal_ref_idc;
 149     int nal_unit_type;
 150 #define NAL_SLICE                1
 151 #define NAL_DPA                  2
 152 #define NAL_DPB                  3
 153 #define NAL_DPC                  4
 154 #define NAL_IDR_SLICE            5
 155 #define NAL_SEI                  6
 156 #define NAL_SPS                  7
 157 #define NAL_PPS                  8
 158 #define NAL_AUD                  9
 159 #define NAL_END_SEQUENCE        10
 160 #define NAL_END_STREAM          11
 161 #define NAL_FILLER_DATA         12
 162 #define NAL_SPS_EXT             13
 163 #define NAL_AUXILIARY_SLICE     19
 164     uint8_t *rbsp_buffer;
 165     int rbsp_buffer_size;
 166
 167     /**
 168       * Used to parse AVC variant of h264
 169       */
 170     int is_avc; ///< this flag is != 0 if codec is avc1
 171     int got_avcC; ///< flag used to parse avcC data only once
 172     int nal_length_size; ///< Number of bytes used for nal length (1, 2 or 4)
 173
 174     int chroma_qp; //QPc
 175
 176     int prev_mb_skipped; //FIXME remove (IMHO not used)
 177
 178     //prediction stuff
 179     int chroma_pred_mode;
 180     int intra16x16_pred_mode;
 181
 182     int top_mb_xy;
 183     int left_mb_xy[2];
 184
 185     int8_t intra4x4_pred_mode_cache[5*8];
 186     int8_t (*intra4x4_pred_mode)[8];
 187     void (*pred4x4  [9+3])(uint8_t *src, uint8_t *topright, int stride);//FIXME move to dsp?
 188     void (*pred8x8l [9+3])(uint8_t *src, int topleft, int topright, int stride);
 189     void (*pred8x8  [4+3])(uint8_t *src, int stride);
 190     void (*pred16x16[4+3])(uint8_t *src, int stride);
 191     unsigned int topleft_samples_available;
 192     unsigned int top_samples_available;
 193     unsigned int topright_samples_available;
 194     unsigned int left_samples_available;
 195     uint8_t (*top_borders[2])[16+2*8];
 196     uint8_t left_border[2*(17+2*9)];
 197
 198     /**
 199      * non zero coeff count cache.
 200      * is 64 if not available.
 201      */
 202     uint8_t non_zero_count_cache[6*8] __align8;
 203     uint8_t (*non_zero_count)[16];
 204
 205     /**
 206      * Motion vector cache.
 207      */
 208     int16_t mv_cache[2][5*8][2] __align8;
 209     int8_t ref_cache[2][5*8] __align8;
 210 #define LIST_NOT_USED -1 //FIXME rename?
 211 #define PART_NOT_AVAILABLE -2
 212
 213     /**
 214      * is 1 if the specific list MV&references are set to 0,0,-2.
 215      */
 216     int mv_cache_clean[2];
 217
 218     /**
 219      * number of neighbors (top and/or left) that used 8x8 dct
 220      */
 221     int neighbor_transform_size;
 222
 223     /**
 224      * block_offset[ 0..23] for frame macroblocks
 225      * block_offset[24..47] for field macroblocks
 226      */
 227     int block_offset[2*(16+8)];
 228
 229     uint32_t *mb2b_xy; //FIXME are these 4 a good idea?
 230     uint32_t *mb2b8_xy;
 231     int b_stride; //FIXME use s->b4_stride
 232     int b8_stride;
 233
 234     int halfpel_flag;
 235     int thirdpel_flag;
 236
 237     int unknown_svq3_flag;
 238     int next_slice_index;
 239
 240     SPS sps_buffer[MAX_SPS_COUNT];
 241     SPS sps; ///< current sps
 242
 243     PPS pps_buffer[MAX_PPS_COUNT];
 244     /**
 245      * current pps
 246      */
 247     PPS pps; //FIXME move to Picture perhaps? (->no) do we need that?
 248
 249     uint32_t dequant4_buffer[6][52][16];
 250     uint32_t dequant8_buffer[2][52][64];
 251     uint32_t (*dequant4_coeff[6])[16];
 252     uint32_t (*dequant8_coeff[2])[64];
 253     int dequant_coeff_pps;     ///< reinit tables when pps changes
 254
 255     int slice_num;
 256     uint8_t *slice_table_base;
 257     uint8_t *slice_table;      ///< slice_table_base + mb_stride + 1
 258     int slice_type;
 259     int slice_type_fixed;
 260
 261     //interlacing specific flags
 262     int mb_aff_frame;
 263     int mb_field_decoding_flag;
 264
 265     int sub_mb_type[4];
 266
 267     //POC stuff
 268     int poc_lsb;
 269     int poc_msb;
 270     int delta_poc_bottom;
 271     int delta_poc[2];
 272     int frame_num;
 273     int prev_poc_msb;             ///< poc_msb of the last reference pic for POC type 0
 274     int prev_poc_lsb;             ///< poc_lsb of the last reference pic for POC type 0
 275     int frame_num_offset;         ///< for POC type 2
 276     int prev_frame_num_offset;    ///< for POC type 2
 277     int prev_frame_num;           ///< frame_num of the last pic for POC type 1/2
 278
 279     /**
 280      * frame_num for frames or 2*frame_num for field pics.
 281      */
 282     int curr_pic_num;
 283
 284     /**
 285      * max_frame_num or 2*max_frame_num for field pics.
 286      */
 287     int max_pic_num;
 288
 289     //Weighted pred stuff
 290     int use_weight;
 291     int use_weight_chroma;
 292     int luma_log2_weight_denom;
 293     int chroma_log2_weight_denom;
 294     int luma_weight[2][16];
 295     int luma_offset[2][16];
 296     int chroma_weight[2][16][2];
 297     int chroma_offset[2][16][2];
 298     int implicit_weight[16][16];
 299
 300     //deblock
 301     int deblocking_filter;         ///< disable_deblocking_filter_idc with 1<->0
 302     int slice_alpha_c0_offset;
 303     int slice_beta_offset;
 304
 305     int redundant_pic_count;
 306
 307     int direct_spatial_mv_pred;
 308     int dist_scale_factor[16];
 309     int map_col_to_list0[2][16];
 310
 311     /**
 312      * num_ref_idx_l0/1_active_minus1 + 1
 313      */
 314     int ref_count[2];// FIXME split for AFF
 315     Picture *short_ref[32];
 316     Picture *long_ref[32];
 317     Picture default_ref_list[2][32];
 318     Picture ref_list[2][32]; //FIXME size?
 319     Picture field_ref_list[2][32]; //FIXME size?
 320     Picture *delayed_pic[16]; //FIXME size?
 321     Picture *delayed_output_pic;
 322
 323     /**
 324      * memory management control operations buffer.
 325      */
 326     MMCO mmco[MAX_MMCO_COUNT];
 327     int mmco_index;
 328
 329     int long_ref_count;  ///< number of actual long term references
 330     int short_ref_count; ///< number of actual short term references
 331
 332     //data partitioning
 333     GetBitContext intra_gb;
 334     GetBitContext inter_gb;
 335     GetBitContext *intra_gb_ptr;
 336     GetBitContext *inter_gb_ptr;
 337
 338     DCTELEM mb[16*24] __align8;
 339
 340     /**
 341      * Cabac
 342      */
 343     CABACContext cabac;
 344     uint8_t      cabac_state[460];
 345     int          cabac_init_idc;
 346
 347     /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0,1,2), 0x0? luma_cbp */
 348     uint16_t     *cbp_table;
 349     int top_cbp;
 350     int left_cbp;
 351     /* chroma_pred_mode for i4x4 or i16x16, else 0 */
 352     uint8_t     *chroma_pred_mode_table;
 353     int         last_qscale_diff;
 354     int16_t     (*mvd_table[2])[2];
 355     int16_t     mvd_cache[2][5*8][2] __align8;
 356     uint8_t     *direct_table;
 357     uint8_t     direct_cache[5*8];
 358
 359     uint8_t zigzag_scan[16];
 360     uint8_t field_scan[16];
 361     const uint8_t *zigzag_scan_q0;
 362     const uint8_t *field_scan_q0;
 363
 364     int x264_build;
 365 }H264Context;
 366
 367 static VLC coeff_token_vlc[4];
 368 static VLC chroma_dc_coeff_token_vlc;
 369
 370 static VLC total_zeros_vlc[15];
 371 static VLC chroma_dc_total_zeros_vlc[3];
 372
 373 static VLC run_vlc[6];
 374 static VLC run7_vlc;
 375
 376 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp);
 377 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);
 378 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);
 379
 380 static inline uint32_t pack16to32(int a, int b){
 381 #ifdef WORDS_BIGENDIAN
 382    return (b&0xFFFF) + (a<<16);
 383 #else
 384    return (a&0xFFFF) + (b<<16);
 385 #endif
 386 }
 387
 388 /**
 389  * fill a rectangle.
 390  * @param h height of the rectangle, should be a constant
 391  * @param w width of the rectangle, should be a constant
 392  * @param size the size of val (1 or 4), should be a constant
 393  */
 394 static inline void fill_rectangle(void *vp, int w, int h, int stride, uint32_t val, int size){ //FIXME ensure this IS inlined
 395     uint8_t *p= (uint8_t*)vp;
 396     assert(size==1 || size==4);
 397
 398     w      *= size;
 399     stride *= size;
 400
 401     assert((((long)vp)&(FFMIN(w, STRIDE_ALIGN)-1)) == 0);
 402     assert((stride&(w-1))==0);
 403 //FIXME check what gcc generates for 64 bit on x86 and possibly write a 32 bit ver of it
 404     if(w==2 && h==2){
 405         *(uint16_t*)(p + 0)=
 406         *(uint16_t*)(p + stride)= size==4 ? val : val*0x0101;
 407     }else if(w==2 && h==4){
 408         *(uint16_t*)(p + 0*stride)=
 409         *(uint16_t*)(p + 1*stride)=
 410         *(uint16_t*)(p + 2*stride)=
 411         *(uint16_t*)(p + 3*stride)= size==4 ? val : val*0x0101;
 412     }else if(w==4 && h==1){
 413         *(uint32_t*)(p + 0*stride)= size==4 ? val : val*0x01010101;
 414     }else if(w==4 && h==2){
 415         *(uint32_t*)(p + 0*stride)=
 416         *(uint32_t*)(p + 1*stride)= size==4 ? val : val*0x01010101;
 417     }else if(w==4 && h==4){
 418         *(uint32_t*)(p + 0*stride)=
 419         *(uint32_t*)(p + 1*stride)=
 420         *(uint32_t*)(p + 2*stride)=
 421         *(uint32_t*)(p + 3*stride)= size==4 ? val : val*0x01010101;
 422     }else if(w==8 && h==1){
 423         *(uint32_t*)(p + 0)=
 424         *(uint32_t*)(p + 4)= size==4 ? val : val*0x01010101;
 425     }else if(w==8 && h==2){
 426         *(uint32_t*)(p + 0 + 0*stride)=
 427         *(uint32_t*)(p + 4 + 0*stride)=
 428         *(uint32_t*)(p + 0 + 1*stride)=
 429         *(uint32_t*)(p + 4 + 1*stride)=  size==4 ? val : val*0x01010101;
 430     }else if(w==8 && h==4){
 431         *(uint64_t*)(p + 0*stride)=
 432         *(uint64_t*)(p + 1*stride)=
 433         *(uint64_t*)(p + 2*stride)=
 434         *(uint64_t*)(p + 3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
 435     }else if(w==16 && h==2){
 436         *(uint64_t*)(p + 0+0*stride)=
 437         *(uint64_t*)(p + 8+0*stride)=
 438         *(uint64_t*)(p + 0+1*stride)=
 439         *(uint64_t*)(p + 8+1*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
 440     }else if(w==16 && h==4){
 441         *(uint64_t*)(p + 0+0*stride)=
 442         *(uint64_t*)(p + 8+0*stride)=
 443         *(uint64_t*)(p + 0+1*stride)=
 444         *(uint64_t*)(p + 8+1*stride)=
 445         *(uint64_t*)(p + 0+2*stride)=
 446         *(uint64_t*)(p + 8+2*stride)=
 447         *(uint64_t*)(p + 0+3*stride)=
 448         *(uint64_t*)(p + 8+3*stride)= size==4 ? val*0x0100000001ULL : val*0x0101010101010101ULL;
 449     }else
 450         assert(0);
 451 }
 452
 453 static inline void fill_caches(H264Context *h, int mb_type, int for_deblock){
 454     MpegEncContext * const s = &h->s;
 455     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
 456     int topleft_xy, top_xy, topright_xy, left_xy[2];
 457     int topleft_type, top_type, topright_type, left_type[2];
 458     int left_block[8];
 459     int i;
 460
 461     //FIXME deblocking can skip fill_caches much of the time with multiple slices too.
 462     // the actual condition is whether we're on the edge of a slice,
 463     // and even then the intra and nnz parts are unnecessary.
 464     if(for_deblock && h->slice_num == 1)
 465         return;
 466
 467     //wow what a mess, why didn't they simplify the interlacing&intra stuff, i can't imagine that these complex rules are worth it
 468
 469     top_xy     = mb_xy  - s->mb_stride;
 470     topleft_xy = top_xy - 1;
 471     topright_xy= top_xy + 1;
 472     left_xy[1] = left_xy[0] = mb_xy-1;
 473     left_block[0]= 0;
 474     left_block[1]= 1;
 475     left_block[2]= 2;
 476     left_block[3]= 3;
 477     left_block[4]= 7;
 478     left_block[5]= 10;
 479     left_block[6]= 8;
 480     left_block[7]= 11;
 481     if(h->mb_aff_frame){
 482         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
 483         const int top_pair_xy      = pair_xy     - s->mb_stride;
 484         const int topleft_pair_xy  = top_pair_xy - 1;
 485         const int topright_pair_xy = top_pair_xy + 1;
 486         const int topleft_mb_frame_flag  = !IS_INTERLACED(s->current_picture.mb_type[topleft_pair_xy]);
 487         const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
 488         const int topright_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[topright_pair_xy]);
 489         const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
 490         const int curr_mb_frame_flag = !IS_INTERLACED(mb_type);
 491         const int bottom = (s->mb_y & 1);
 492         tprintf("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);
 493         if (bottom
 494                 ? !curr_mb_frame_flag // bottom macroblock
 495                 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
 496                 ) {
 497             top_xy -= s->mb_stride;
 498         }
 499         if (bottom
 500                 ? !curr_mb_frame_flag // bottom macroblock
 501                 : (!curr_mb_frame_flag && !topleft_mb_frame_flag) // top macroblock
 502                 ) {
 503             topleft_xy -= s->mb_stride;
 504         }
 505         if (bottom
 506                 ? !curr_mb_frame_flag // bottom macroblock
 507                 : (!curr_mb_frame_flag && !topright_mb_frame_flag) // top macroblock
 508                 ) {
 509             topright_xy -= s->mb_stride;
 510         }
 511         if (left_mb_frame_flag != curr_mb_frame_flag) {
 512             left_xy[1] = left_xy[0] = pair_xy - 1;
 513             if (curr_mb_frame_flag) {
 514                 if (bottom) {
 515                     left_block[0]= 2;
 516                     left_block[1]= 2;
 517                     left_block[2]= 3;
 518                     left_block[3]= 3;
 519                     left_block[4]= 8;
 520                     left_block[5]= 11;
 521                     left_block[6]= 8;
 522                     left_block[7]= 11;
 523                 } else {
 524                     left_block[0]= 0;
 525                     left_block[1]= 0;
 526                     left_block[2]= 1;
 527                     left_block[3]= 1;
 528                     left_block[4]= 7;
 529                     left_block[5]= 10;
 530                     left_block[6]= 7;
 531                     left_block[7]= 10;
 532                 }
 533             } else {
 534                 left_xy[1] += s->mb_stride;
 535                 //left_block[0]= 0;
 536                 left_block[1]= 2;
 537                 left_block[2]= 0;
 538                 left_block[3]= 2;
 539                 //left_block[4]= 7;
 540                 left_block[5]= 10;
 541                 left_block[6]= 7;
 542                 left_block[7]= 10;
 543             }
 544         }
 545     }
 546
 547     h->top_mb_xy = top_xy;
 548     h->left_mb_xy[0] = left_xy[0];
 549     h->left_mb_xy[1] = left_xy[1];
 550     if(for_deblock){
 551         topleft_type = h->slice_table[topleft_xy ] < 255 ? s->current_picture.mb_type[topleft_xy] : 0;
 552         top_type     = h->slice_table[top_xy     ] < 255 ? s->current_picture.mb_type[top_xy]     : 0;
 553         topright_type= h->slice_table[topright_xy] < 255 ? s->current_picture.mb_type[topright_xy]: 0;
 554         left_type[0] = h->slice_table[left_xy[0] ] < 255 ? s->current_picture.mb_type[left_xy[0]] : 0;
 555         left_type[1] = h->slice_table[left_xy[1] ] < 255 ? s->current_picture.mb_type[left_xy[1]] : 0;
 556     }else{
 557         topleft_type = h->slice_table[topleft_xy ] == h->slice_num ? s->current_picture.mb_type[topleft_xy] : 0;
 558         top_type     = h->slice_table[top_xy     ] == h->slice_num ? s->current_picture.mb_type[top_xy]     : 0;
 559         topright_type= h->slice_table[topright_xy] == h->slice_num ? s->current_picture.mb_type[topright_xy]: 0;
 560         left_type[0] = h->slice_table[left_xy[0] ] == h->slice_num ? s->current_picture.mb_type[left_xy[0]] : 0;
 561         left_type[1] = h->slice_table[left_xy[1] ] == h->slice_num ? s->current_picture.mb_type[left_xy[1]] : 0;
 562     }
 563
 564     if(IS_INTRA(mb_type)){
 565         h->topleft_samples_available=
 566         h->top_samples_available=
 567         h->left_samples_available= 0xFFFF;
 568         h->topright_samples_available= 0xEEEA;
 569
 570         if(!IS_INTRA(top_type) && (top_type==0 || h->pps.constrained_intra_pred)){
 571             h->topleft_samples_available= 0xB3FF;
 572             h->top_samples_available= 0x33FF;
 573             h->topright_samples_available= 0x26EA;
 574         }
 575         for(i=0; i<2; i++){
 576             if(!IS_INTRA(left_type[i]) && (left_type[i]==0 || h->pps.constrained_intra_pred)){
 577                 h->topleft_samples_available&= 0xDF5F;
 578                 h->left_samples_available&= 0x5F5F;
 579             }
 580         }
 581
 582         if(!IS_INTRA(topleft_type) && (topleft_type==0 || h->pps.constrained_intra_pred))
 583             h->topleft_samples_available&= 0x7FFF;
 584
 585         if(!IS_INTRA(topright_type) && (topright_type==0 || h->pps.constrained_intra_pred))
 586             h->topright_samples_available&= 0xFBFF;
 587
 588         if(IS_INTRA4x4(mb_type)){
 589             if(IS_INTRA4x4(top_type)){
 590                 h->intra4x4_pred_mode_cache[4+8*0]= h->intra4x4_pred_mode[top_xy][4];
 591                 h->intra4x4_pred_mode_cache[5+8*0]= h->intra4x4_pred_mode[top_xy][5];
 592                 h->intra4x4_pred_mode_cache[6+8*0]= h->intra4x4_pred_mode[top_xy][6];
 593                 h->intra4x4_pred_mode_cache[7+8*0]= h->intra4x4_pred_mode[top_xy][3];
 594             }else{
 595                 int pred;
 596                 if(!top_type || (IS_INTER(top_type) && h->pps.constrained_intra_pred))
 597                     pred= -1;
 598                 else{
 599                     pred= 2;
 600                 }
 601                 h->intra4x4_pred_mode_cache[4+8*0]=
 602                 h->intra4x4_pred_mode_cache[5+8*0]=
 603                 h->intra4x4_pred_mode_cache[6+8*0]=
 604                 h->intra4x4_pred_mode_cache[7+8*0]= pred;
 605             }
 606             for(i=0; i<2; i++){
 607                 if(IS_INTRA4x4(left_type[i])){
 608                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[0+2*i]];
 609                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= h->intra4x4_pred_mode[left_xy[i]][left_block[1+2*i]];
 610                 }else{
 611                     int pred;
 612                     if(!left_type[i] || (IS_INTER(left_type[i]) && h->pps.constrained_intra_pred))
 613                         pred= -1;
 614                     else{
 615                         pred= 2;
 616                     }
 617                     h->intra4x4_pred_mode_cache[3+8*1 + 2*8*i]=
 618                     h->intra4x4_pred_mode_cache[3+8*2 + 2*8*i]= pred;
 619                 }
 620             }
 621         }
 622     }
 623
 624
 625 /*
 626 0 . T T. T T T T
 627 1 L . .L . . . .
 628 2 L . .L . . . .
 629 3 . T TL . . . .
 630 4 L . .L . . . .
 631 5 L . .. . . . .
 632 */
 633 //FIXME constraint_intra_pred & partitioning & nnz (lets hope this is just a typo in the spec)
 634     if(top_type){
 635         h->non_zero_count_cache[4+8*0]= h->non_zero_count[top_xy][4];
 636         h->non_zero_count_cache[5+8*0]= h->non_zero_count[top_xy][5];
 637         h->non_zero_count_cache[6+8*0]= h->non_zero_count[top_xy][6];
 638         h->non_zero_count_cache[7+8*0]= h->non_zero_count[top_xy][3];
 639
 640         h->non_zero_count_cache[1+8*0]= h->non_zero_count[top_xy][9];
 641         h->non_zero_count_cache[2+8*0]= h->non_zero_count[top_xy][8];
 642
 643         h->non_zero_count_cache[1+8*3]= h->non_zero_count[top_xy][12];
 644         h->non_zero_count_cache[2+8*3]= h->non_zero_count[top_xy][11];
 645
 646     }else{
 647         h->non_zero_count_cache[4+8*0]=
 648         h->non_zero_count_cache[5+8*0]=
 649         h->non_zero_count_cache[6+8*0]=
 650         h->non_zero_count_cache[7+8*0]=
 651
 652         h->non_zero_count_cache[1+8*0]=
 653         h->non_zero_count_cache[2+8*0]=
 654
 655         h->non_zero_count_cache[1+8*3]=
 656         h->non_zero_count_cache[2+8*3]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
 657
 658     }
 659
 660     for (i=0; i<2; i++) {
 661         if(left_type[i]){
 662             h->non_zero_count_cache[3+8*1 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[0+2*i]];
 663             h->non_zero_count_cache[3+8*2 + 2*8*i]= h->non_zero_count[left_xy[i]][left_block[1+2*i]];
 664             h->non_zero_count_cache[0+8*1 +   8*i]= h->non_zero_count[left_xy[i]][left_block[4+2*i]];
 665             h->non_zero_count_cache[0+8*4 +   8*i]= h->non_zero_count[left_xy[i]][left_block[5+2*i]];
 666         }else{
 667             h->non_zero_count_cache[3+8*1 + 2*8*i]=
 668             h->non_zero_count_cache[3+8*2 + 2*8*i]=
 669             h->non_zero_count_cache[0+8*1 +   8*i]=
 670             h->non_zero_count_cache[0+8*4 +   8*i]= h->pps.cabac && !IS_INTRA(mb_type) ? 0 : 64;
 671         }
 672     }
 673
 674     if( h->pps.cabac ) {
 675         // top_cbp
 676         if(top_type) {
 677             h->top_cbp = h->cbp_table[top_xy];
 678         } else if(IS_INTRA(mb_type)) {
 679             h->top_cbp = 0x1C0;
 680         } else {
 681             h->top_cbp = 0;
 682         }
 683         // left_cbp
 684         if (left_type[0]) {
 685             h->left_cbp = h->cbp_table[left_xy[0]] & 0x1f0;
 686         } else if(IS_INTRA(mb_type)) {
 687             h->left_cbp = 0x1C0;
 688         } else {
 689             h->left_cbp = 0;
 690         }
 691         if (left_type[0]) {
 692             h->left_cbp |= ((h->cbp_table[left_xy[0]]>>((left_block[0]&(~1))+1))&0x1) << 1;
 693         }
 694         if (left_type[1]) {
 695             h->left_cbp |= ((h->cbp_table[left_xy[1]]>>((left_block[2]&(~1))+1))&0x1) << 3;
 696         }
 697     }
 698
 699 #if 1
 700     //FIXME direct mb can skip much of this
 701     if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
 702         int list;
 703         for(list=0; list<1+(h->slice_type==B_TYPE); list++){
 704             if(!USES_LIST(mb_type, list) && !IS_DIRECT(mb_type) && !h->deblocking_filter){
 705                 /*if(!h->mv_cache_clean[list]){
 706                     memset(h->mv_cache [list],  0, 8*5*2*sizeof(int16_t)); //FIXME clean only input? clean at all?
 707                     memset(h->ref_cache[list], PART_NOT_AVAILABLE, 8*5*sizeof(int8_t));
 708                     h->mv_cache_clean[list]= 1;
 709                 }*/
 710                 continue;
 711             }
 712             h->mv_cache_clean[list]= 0;
 713
 714             if(IS_INTER(top_type)){
 715                 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
 716                 const int b8_xy= h->mb2b8_xy[top_xy] + h->b8_stride;
 717                 *(uint32_t*)h->mv_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 0];
 718                 *(uint32_t*)h->mv_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 1];
 719                 *(uint32_t*)h->mv_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 2];
 720                 *(uint32_t*)h->mv_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + 3];
 721                 h->ref_cache[list][scan8[0] + 0 - 1*8]=
 722                 h->ref_cache[list][scan8[0] + 1 - 1*8]= s->current_picture.ref_index[list][b8_xy + 0];
 723                 h->ref_cache[list][scan8[0] + 2 - 1*8]=
 724                 h->ref_cache[list][scan8[0] + 3 - 1*8]= s->current_picture.ref_index[list][b8_xy + 1];
 725             }else{
 726                 *(uint32_t*)h->mv_cache [list][scan8[0] + 0 - 1*8]=
 727                 *(uint32_t*)h->mv_cache [list][scan8[0] + 1 - 1*8]=
 728                 *(uint32_t*)h->mv_cache [list][scan8[0] + 2 - 1*8]=
 729                 *(uint32_t*)h->mv_cache [list][scan8[0] + 3 - 1*8]= 0;
 730                 *(uint32_t*)&h->ref_cache[list][scan8[0] + 0 - 1*8]= ((top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE)&0xFF)*0x01010101;
 731             }
 732
 733             //FIXME unify cleanup or sth
 734             if(IS_INTER(left_type[0])){
 735                 const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
 736                 const int b8_xy= h->mb2b8_xy[left_xy[0]] + 1;
 737                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 0*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[0]];
 738                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[1]];
 739                 h->ref_cache[list][scan8[0] - 1 + 0*8]=
 740                 h->ref_cache[list][scan8[0] - 1 + 1*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[0]>>1)];
 741             }else{
 742                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 0*8]=
 743                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 1*8]= 0;
 744                 h->ref_cache[list][scan8[0] - 1 + 0*8]=
 745                 h->ref_cache[list][scan8[0] - 1 + 1*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 746             }
 747
 748             if(IS_INTER(left_type[1])){
 749                 const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
 750                 const int b8_xy= h->mb2b8_xy[left_xy[1]] + 1;
 751                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 2*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[2]];
 752                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 + 3*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy + h->b_stride*left_block[3]];
 753                 h->ref_cache[list][scan8[0] - 1 + 2*8]=
 754                 h->ref_cache[list][scan8[0] - 1 + 3*8]= s->current_picture.ref_index[list][b8_xy + h->b8_stride*(left_block[2]>>1)];
 755             }else{
 756                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 2*8]=
 757                 *(uint32_t*)h->mv_cache [list][scan8[0] - 1 + 3*8]= 0;
 758                 h->ref_cache[list][scan8[0] - 1 + 2*8]=
 759                 h->ref_cache[list][scan8[0] - 1 + 3*8]= left_type[0] ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 760                 assert((!left_type[0]) == (!left_type[1]));
 761             }
 762
 763             if(for_deblock || (IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred))
 764                 continue;
 765
 766             if(IS_INTER(topleft_type)){
 767                 const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
 768                 const int b8_xy= h->mb2b8_xy[topleft_xy] + 1 + h->b8_stride;
 769                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
 770                 h->ref_cache[list][scan8[0] - 1 - 1*8]= s->current_picture.ref_index[list][b8_xy];
 771             }else{
 772                 *(uint32_t*)h->mv_cache[list][scan8[0] - 1 - 1*8]= 0;
 773                 h->ref_cache[list][scan8[0] - 1 - 1*8]= topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 774             }
 775
 776             if(IS_INTER(topright_type)){
 777                 const int b_xy= h->mb2b_xy[topright_xy] + 3*h->b_stride;
 778                 const int b8_xy= h->mb2b8_xy[topright_xy] + h->b8_stride;
 779                 *(uint32_t*)h->mv_cache[list][scan8[0] + 4 - 1*8]= *(uint32_t*)s->current_picture.motion_val[list][b_xy];
 780                 h->ref_cache[list][scan8[0] + 4 - 1*8]= s->current_picture.ref_index[list][b8_xy];
 781             }else{
 782                 *(uint32_t*)h->mv_cache [list][scan8[0] + 4 - 1*8]= 0;
 783                 h->ref_cache[list][scan8[0] + 4 - 1*8]= topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE;
 784             }
 785
 786
 787             h->ref_cache[list][scan8[5 ]+1] =
 788             h->ref_cache[list][scan8[7 ]+1] =
 789             h->ref_cache[list][scan8[13]+1] =  //FIXME remove past 3 (init somewhere else)
 790             h->ref_cache[list][scan8[4 ]] =
 791             h->ref_cache[list][scan8[12]] = PART_NOT_AVAILABLE;
 792             *(uint32_t*)h->mv_cache [list][scan8[5 ]+1]=
 793             *(uint32_t*)h->mv_cache [list][scan8[7 ]+1]=
 794             *(uint32_t*)h->mv_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
 795             *(uint32_t*)h->mv_cache [list][scan8[4 ]]=
 796             *(uint32_t*)h->mv_cache [list][scan8[12]]= 0;
 797
 798             if( h->pps.cabac ) {
 799                 /* XXX beurk, Load mvd */
 800                 if(IS_INTER(topleft_type)){
 801                     const int b_xy = h->mb2b_xy[topleft_xy] + 3 + 3*h->b_stride;
 802                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy];
 803                 }else{
 804                     *(uint32_t*)h->mvd_cache[list][scan8[0] - 1 - 1*8]= 0;
 805                 }
 806
 807                 if(IS_INTER(top_type)){
 808                     const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
 809                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 0 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 0];
 810                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 1 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 1];
 811                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 2 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 2];
 812                     *(uint32_t*)h->mvd_cache[list][scan8[0] + 3 - 1*8]= *(uint32_t*)h->mvd_table[list][b_xy + 3];
 813                 }else{
 814                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 0 - 1*8]=
 815                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 1 - 1*8]=
 816                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 2 - 1*8]=
 817                     *(uint32_t*)h->mvd_cache [list][scan8[0] + 3 - 1*8]= 0;
 818                 }
 819                 if(IS_INTER(left_type[0])){
 820                     const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
 821                     *(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]];
 822                     *(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]];
 823                 }else{
 824                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 0*8]=
 825                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 1*8]= 0;
 826                 }
 827                 if(IS_INTER(left_type[1])){
 828                     const int b_xy= h->mb2b_xy[left_xy[1]] + 3;
 829                     *(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]];
 830                     *(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]];
 831                 }else{
 832                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 2*8]=
 833                     *(uint32_t*)h->mvd_cache [list][scan8[0] - 1 + 3*8]= 0;
 834                 }
 835                 *(uint32_t*)h->mvd_cache [list][scan8[5 ]+1]=
 836                 *(uint32_t*)h->mvd_cache [list][scan8[7 ]+1]=
 837                 *(uint32_t*)h->mvd_cache [list][scan8[13]+1]= //FIXME remove past 3 (init somewhere else)
 838                 *(uint32_t*)h->mvd_cache [list][scan8[4 ]]=
 839                 *(uint32_t*)h->mvd_cache [list][scan8[12]]= 0;
 840
 841                 if(h->slice_type == B_TYPE){
 842                     fill_rectangle(&h->direct_cache[scan8[0]], 4, 4, 8, 0, 1);
 843
 844                     if(IS_DIRECT(top_type)){
 845                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0x01010101;
 846                     }else if(IS_8X8(top_type)){
 847                         int b8_xy = h->mb2b8_xy[top_xy] + h->b8_stride;
 848                         h->direct_cache[scan8[0] + 0 - 1*8]= h->direct_table[b8_xy];
 849                         h->direct_cache[scan8[0] + 2 - 1*8]= h->direct_table[b8_xy + 1];
 850                     }else{
 851                         *(uint32_t*)&h->direct_cache[scan8[0] - 1*8]= 0;
 852                     }
 853
 854                     //FIXME interlacing
 855                     if(IS_DIRECT(left_type[0])){
 856                         h->direct_cache[scan8[0] - 1 + 0*8]=
 857                         h->direct_cache[scan8[0] - 1 + 2*8]= 1;
 858                     }else if(IS_8X8(left_type[0])){
 859                         int b8_xy = h->mb2b8_xy[left_xy[0]] + 1;
 860                         h->direct_cache[scan8[0] - 1 + 0*8]= h->direct_table[b8_xy];
 861                         h->direct_cache[scan8[0] - 1 + 2*8]= h->direct_table[b8_xy + h->b8_stride];
 862                     }else{
 863                         h->direct_cache[scan8[0] - 1 + 0*8]=
 864                         h->direct_cache[scan8[0] - 1 + 2*8]= 0;
 865                     }
 866                 }
 867             }
 868         }
 869     }
 870 #endif
 871
 872     h->neighbor_transform_size= !!IS_8x8DCT(top_type) + !!IS_8x8DCT(left_type[0]);
 873 }
 874
 875 static inline void write_back_intra_pred_mode(H264Context *h){
 876     MpegEncContext * const s = &h->s;
 877     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
 878
 879     h->intra4x4_pred_mode[mb_xy][0]= h->intra4x4_pred_mode_cache[7+8*1];
 880     h->intra4x4_pred_mode[mb_xy][1]= h->intra4x4_pred_mode_cache[7+8*2];
 881     h->intra4x4_pred_mode[mb_xy][2]= h->intra4x4_pred_mode_cache[7+8*3];
 882     h->intra4x4_pred_mode[mb_xy][3]= h->intra4x4_pred_mode_cache[7+8*4];
 883     h->intra4x4_pred_mode[mb_xy][4]= h->intra4x4_pred_mode_cache[4+8*4];
 884     h->intra4x4_pred_mode[mb_xy][5]= h->intra4x4_pred_mode_cache[5+8*4];
 885     h->intra4x4_pred_mode[mb_xy][6]= h->intra4x4_pred_mode_cache[6+8*4];
 886 }
 887
 888 /**
 889  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 890  */
 891 static inline int check_intra4x4_pred_mode(H264Context *h){
 892     MpegEncContext * const s = &h->s;
 893     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
 894     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
 895     int i;
 896
 897     if(!(h->top_samples_available&0x8000)){
 898         for(i=0; i<4; i++){
 899             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
 900             if(status<0){
 901                 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);
 902                 return -1;
 903             } else if(status){
 904                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
 905             }
 906         }
 907     }
 908
 909     if(!(h->left_samples_available&0x8000)){
 910         for(i=0; i<4; i++){
 911             int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
 912             if(status<0){
 913                 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);
 914                 return -1;
 915             } else if(status){
 916                 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
 917             }
 918         }
 919     }
 920
 921     return 0;
 922 } //FIXME cleanup like next
 923
 924 /**
 925  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 926  */
 927 static inline int check_intra_pred_mode(H264Context *h, int mode){
 928     MpegEncContext * const s = &h->s;
 929     static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
 930     static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
 931
 932     if(mode < 0 || mode > 6) {
 933         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);
 934         return -1;
 935     }
 936
 937     if(!(h->top_samples_available&0x8000)){
 938         mode= top[ mode ];
 939         if(mode<0){
 940             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);
 941             return -1;
 942         }
 943     }
 944
 945     if(!(h->left_samples_available&0x8000)){
 946         mode= left[ mode ];
 947         if(mode<0){
 948             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);
 949             return -1;
 950         }
 951     }
 952
 953     return mode;
 954 }
 955
 956 /**
 957  * gets the predicted intra4x4 prediction mode.
 958  */
 959 static inline int pred_intra_mode(H264Context *h, int n){
 960     const int index8= scan8[n];
 961     const int left= h->intra4x4_pred_mode_cache[index8 - 1];
 962     const int top = h->intra4x4_pred_mode_cache[index8 - 8];
 963     const int min= FFMIN(left, top);
 964
 965     tprintf("mode:%d %d min:%d\n", left ,top, min);
 966
 967     if(min<0) return DC_PRED;
 968     else      return min;
 969 }
 970
 971 static inline void write_back_non_zero_count(H264Context *h){
 972     MpegEncContext * const s = &h->s;
 973     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
 974
 975     h->non_zero_count[mb_xy][0]= h->non_zero_count_cache[7+8*1];
 976     h->non_zero_count[mb_xy][1]= h->non_zero_count_cache[7+8*2];
 977     h->non_zero_count[mb_xy][2]= h->non_zero_count_cache[7+8*3];
 978     h->non_zero_count[mb_xy][3]= h->non_zero_count_cache[7+8*4];
 979     h->non_zero_count[mb_xy][4]= h->non_zero_count_cache[4+8*4];
 980     h->non_zero_count[mb_xy][5]= h->non_zero_count_cache[5+8*4];
 981     h->non_zero_count[mb_xy][6]= h->non_zero_count_cache[6+8*4];
 982
 983     h->non_zero_count[mb_xy][9]= h->non_zero_count_cache[1+8*2];
 984     h->non_zero_count[mb_xy][8]= h->non_zero_count_cache[2+8*2];
 985     h->non_zero_count[mb_xy][7]= h->non_zero_count_cache[2+8*1];
 986
 987     h->non_zero_count[mb_xy][12]=h->non_zero_count_cache[1+8*5];
 988     h->non_zero_count[mb_xy][11]=h->non_zero_count_cache[2+8*5];
 989     h->non_zero_count[mb_xy][10]=h->non_zero_count_cache[2+8*4];
 990 }
 991
 992 /**
 993  * gets the predicted number of non zero coefficients.
 994  * @param n block index
 995  */
 996 static inline int pred_non_zero_count(H264Context *h, int n){
 997     const int index8= scan8[n];
 998     const int left= h->non_zero_count_cache[index8 - 1];
 999     const int top = h->non_zero_count_cache[index8 - 8];
1000     int i= left + top;
1001
1002     if(i<64) i= (i+1)>>1;
1003
1004     tprintf("pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
1005
1006     return i&31;
1007 }
1008
1009 static inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, int i, int list, int part_width){
1010     const int topright_ref= h->ref_cache[list][ i - 8 + part_width ];
1011
1012     if(topright_ref != PART_NOT_AVAILABLE){
1013         *C= h->mv_cache[list][ i - 8 + part_width ];
1014         return topright_ref;
1015     }else{
1016         tprintf("topright MV not available\n");
1017
1018         *C= h->mv_cache[list][ i - 8 - 1 ];
1019         return h->ref_cache[list][ i - 8 - 1 ];
1020     }
1021 }
1022
1023 /**
1024  * gets the predicted MV.
1025  * @param n the block index
1026  * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
1027  * @param mx the x component of the predicted motion vector
1028  * @param my the y component of the predicted motion vector
1029  */
1030 static inline void pred_motion(H264Context * const h, int n, int part_width, int list, int ref, int * const mx, int * const my){
1031     const int index8= scan8[n];
1032     const int top_ref=      h->ref_cache[list][ index8 - 8 ];
1033     const int left_ref=     h->ref_cache[list][ index8 - 1 ];
1034     const int16_t * const A= h->mv_cache[list][ index8 - 1 ];
1035     const int16_t * const B= h->mv_cache[list][ index8 - 8 ];
1036     const int16_t * C;
1037     int diagonal_ref, match_count;
1038
1039     assert(part_width==1 || part_width==2 || part_width==4);
1040
1041 /* mv_cache
1042   B . . A T T T T
1043   U . . L . . , .
1044   U . . L . . . .
1045   U . . L . . , .
1046   . . . L . . . .
1047 */
1048
1049     diagonal_ref= fetch_diagonal_mv(h, &C, index8, list, part_width);
1050     match_count= (diagonal_ref==ref) + (top_ref==ref) + (left_ref==ref);
1051     tprintf("pred_motion match_count=%d\n", match_count);
1052     if(match_count > 1){ //most common
1053         *mx= mid_pred(A[0], B[0], C[0]);
1054         *my= mid_pred(A[1], B[1], C[1]);
1055     }else if(match_count==1){
1056         if(left_ref==ref){
1057             *mx= A[0];
1058             *my= A[1];
1059         }else if(top_ref==ref){
1060             *mx= B[0];
1061             *my= B[1];
1062         }else{
1063             *mx= C[0];
1064             *my= C[1];
1065         }
1066     }else{
1067         if(top_ref == PART_NOT_AVAILABLE && diagonal_ref == PART_NOT_AVAILABLE && left_ref != PART_NOT_AVAILABLE){
1068             *mx= A[0];
1069             *my= A[1];
1070         }else{
1071             *mx= mid_pred(A[0], B[0], C[0]);
1072             *my= mid_pred(A[1], B[1], C[1]);
1073         }
1074     }
1075
1076     tprintf("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);
1077 }
1078
1079 /**
1080  * gets the directionally predicted 16x8 MV.
1081  * @param n the block index
1082  * @param mx the x component of the predicted motion vector
1083  * @param my the y component of the predicted motion vector
1084  */
1085 static inline void pred_16x8_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
1086     if(n==0){
1087         const int top_ref=      h->ref_cache[list][ scan8[0] - 8 ];
1088         const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
1089
1090         tprintf("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);
1091
1092         if(top_ref == ref){
1093             *mx= B[0];
1094             *my= B[1];
1095             return;
1096         }
1097     }else{
1098         const int left_ref=     h->ref_cache[list][ scan8[8] - 1 ];
1099         const int16_t * const A= h->mv_cache[list][ scan8[8] - 1 ];
1100
1101         tprintf("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);
1102
1103         if(left_ref == ref){
1104             *mx= A[0];
1105             *my= A[1];
1106             return;
1107         }
1108     }
1109
1110     //RARE
1111     pred_motion(h, n, 4, list, ref, mx, my);
1112 }
1113
1114 /**
1115  * gets the directionally predicted 8x16 MV.
1116  * @param n the block index
1117  * @param mx the x component of the predicted motion vector
1118  * @param my the y component of the predicted motion vector
1119  */
1120 static inline void pred_8x16_motion(H264Context * const h, int n, int list, int ref, int * const mx, int * const my){
1121     if(n==0){
1122         const int left_ref=      h->ref_cache[list][ scan8[0] - 1 ];
1123         const int16_t * const A=  h->mv_cache[list][ scan8[0] - 1 ];
1124
1125         tprintf("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);
1126
1127         if(left_ref == ref){
1128             *mx= A[0];
1129             *my= A[1];
1130             return;
1131         }
1132     }else{
1133         const int16_t * C;
1134         int diagonal_ref;
1135
1136         diagonal_ref= fetch_diagonal_mv(h, &C, scan8[4], list, 2);
1137
1138         tprintf("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);
1139
1140         if(diagonal_ref == ref){
1141             *mx= C[0];
1142             *my= C[1];
1143             return;
1144         }
1145     }
1146
1147     //RARE
1148     pred_motion(h, n, 2, list, ref, mx, my);
1149 }
1150
1151 static inline void pred_pskip_motion(H264Context * const h, int * const mx, int * const my){
1152     const int top_ref = h->ref_cache[0][ scan8[0] - 8 ];
1153     const int left_ref= h->ref_cache[0][ scan8[0] - 1 ];
1154
1155     tprintf("pred_pskip: (%d) (%d) at %2d %2d\n", top_ref, left_ref, h->s.mb_x, h->s.mb_y);
1156
1157     if(top_ref == PART_NOT_AVAILABLE || left_ref == PART_NOT_AVAILABLE
1158        || (top_ref == 0  && *(uint32_t*)h->mv_cache[0][ scan8[0] - 8 ] == 0)
1159        || (left_ref == 0 && *(uint32_t*)h->mv_cache[0][ scan8[0] - 1 ] == 0)){
1160
1161         *mx = *my = 0;
1162         return;
1163     }
1164
1165     pred_motion(h, 0, 4, 0, 0, mx, my);
1166
1167     return;
1168 }
1169
1170 static inline void direct_dist_scale_factor(H264Context * const h){
1171     const int poc = h->s.current_picture_ptr->poc;
1172     const int poc1 = h->ref_list[1][0].poc;
1173     int i;
1174     for(i=0; i<h->ref_count[0]; i++){
1175         int poc0 = h->ref_list[0][i].poc;
1176         int td = clip(poc1 - poc0, -128, 127);
1177         if(td == 0 /* FIXME || pic0 is a long-term ref */){
1178             h->dist_scale_factor[i] = 256;
1179         }else{
1180             int tb = clip(poc - poc0, -128, 127);
1181             int tx = (16384 + (ABS(td) >> 1)) / td;
1182             h->dist_scale_factor[i] = clip((tb*tx + 32) >> 6, -1024, 1023);
1183         }
1184     }
1185 }
1186 static inline void direct_ref_list_init(H264Context * const h){
1187     MpegEncContext * const s = &h->s;
1188     Picture * const ref1 = &h->ref_list[1][0];
1189     Picture * const cur = s->current_picture_ptr;
1190     int list, i, j;
1191     if(cur->pict_type == I_TYPE)
1192         cur->ref_count[0] = 0;
1193     if(cur->pict_type != B_TYPE)
1194         cur->ref_count[1] = 0;
1195     for(list=0; list<2; list++){
1196         cur->ref_count[list] = h->ref_count[list];
1197         for(j=0; j<h->ref_count[list]; j++)
1198             cur->ref_poc[list][j] = h->ref_list[list][j].poc;
1199     }
1200     if(cur->pict_type != B_TYPE || h->direct_spatial_mv_pred)
1201         return;
1202     for(list=0; list<2; list++){
1203         for(i=0; i<ref1->ref_count[list]; i++){
1204             const int poc = ref1->ref_poc[list][i];
1205             h->map_col_to_list0[list][i] = PART_NOT_AVAILABLE;
1206             for(j=0; j<h->ref_count[list]; j++)
1207                 if(h->ref_list[list][j].poc == poc){
1208                     h->map_col_to_list0[list][i] = j;
1209                     break;
1210                 }
1211         }
1212     }
1213 }
1214
1215 static inline void pred_direct_motion(H264Context * const h, int *mb_type){
1216     MpegEncContext * const s = &h->s;
1217     const int mb_xy =   s->mb_x +   s->mb_y*s->mb_stride;
1218     const int b8_xy = 2*s->mb_x + 2*s->mb_y*h->b8_stride;
1219     const int b4_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
1220     const int mb_type_col = h->ref_list[1][0].mb_type[mb_xy];
1221     const int16_t (*l1mv0)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[0][b4_xy];
1222     const int16_t (*l1mv1)[2] = (const int16_t (*)[2]) &h->ref_list[1][0].motion_val[1][b4_xy];
1223     const int8_t *l1ref0 = &h->ref_list[1][0].ref_index[0][b8_xy];
1224     const int8_t *l1ref1 = &h->ref_list[1][0].ref_index[1][b8_xy];
1225     const int is_b8x8 = IS_8X8(*mb_type);
1226     int sub_mb_type;
1227     int i8, i4;
1228
1229     if(IS_8X8(mb_type_col) && !h->sps.direct_8x8_inference_flag){
1230         /* FIXME save sub mb types from previous frames (or derive from MVs)
1231          * so we know exactly what block size to use */
1232         sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */
1233         *mb_type =    MB_TYPE_8x8|MB_TYPE_L0L1;
1234     }else if(!is_b8x8 && (IS_16X16(mb_type_col) || IS_INTRA(mb_type_col))){
1235         sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1236         *mb_type =    MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
1237     }else{
1238         sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
1239         *mb_type =    MB_TYPE_8x8|MB_TYPE_L0L1;
1240     }
1241     if(!is_b8x8)
1242         *mb_type |= MB_TYPE_DIRECT2;
1243
1244     tprintf("mb_type = %08x, sub_mb_type = %08x, is_b8x8 = %d, mb_type_col = %08x\n", *mb_type, sub_mb_type, is_b8x8, mb_type_col);
1245
1246     if(h->direct_spatial_mv_pred){
1247         int ref[2];
1248         int mv[2][2];
1249         int list;
1250
1251         /* ref = min(neighbors) */
1252         for(list=0; list<2; list++){
1253             int refa = h->ref_cache[list][scan8[0] - 1];
1254             int refb = h->ref_cache[list][scan8[0] - 8];
1255             int refc = h->ref_cache[list][scan8[0] - 8 + 4];
1256             if(refc == -2)
1257                 refc = h->ref_cache[list][scan8[0] - 8 - 1];
1258             ref[list] = refa;
1259             if(ref[list] < 0 || (refb < ref[list] && refb >= 0))
1260                 ref[list] = refb;
1261             if(ref[list] < 0 || (refc < ref[list] && refc >= 0))
1262                 ref[list] = refc;
1263             if(ref[list] < 0)
1264                 ref[list] = -1;
1265         }
1266
1267         if(ref[0] < 0 && ref[1] < 0){
1268             ref[0] = ref[1] = 0;
1269             mv[0][0] = mv[0][1] =
1270             mv[1][0] = mv[1][1] = 0;
1271         }else{
1272             for(list=0; list<2; list++){
1273                 if(ref[list] >= 0)
1274                     pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
1275                 else
1276                     mv[list][0] = mv[list][1] = 0;
1277             }
1278         }
1279
1280         if(ref[1] < 0){
1281             *mb_type &= ~MB_TYPE_P0L1;
1282             sub_mb_type &= ~MB_TYPE_P0L1;
1283         }else if(ref[0] < 0){
1284             *mb_type &= ~MB_TYPE_P0L0;
1285             sub_mb_type &= ~MB_TYPE_P0L0;
1286         }
1287
1288         if(IS_16X16(*mb_type)){
1289             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
1290             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
1291             if(!IS_INTRA(mb_type_col)
1292                && (   (l1ref0[0] == 0 && ABS(l1mv0[0][0]) <= 1 && ABS(l1mv0[0][1]) <= 1)
1293                    || (l1ref0[0]  < 0 && l1ref1[0] == 0 && ABS(l1mv1[0][0]) <= 1 && ABS(l1mv1[0][1]) <= 1
1294                        && (h->x264_build>33 || !h->x264_build)))){
1295                 if(ref[0] > 0)
1296                     fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1297                 else
1298                     fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1299                 if(ref[1] > 0)
1300                     fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1301                 else
1302                     fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1303             }else{
1304                 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1305                 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1306             }
1307         }else{
1308             for(i8=0; i8<4; i8++){
1309                 const int x8 = i8&1;
1310                 const int y8 = i8>>1;
1311
1312                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1313                     continue;
1314                 h->sub_mb_type[i8] = sub_mb_type;
1315
1316                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mv[0][0],mv[0][1]), 4);
1317                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mv[1][0],mv[1][1]), 4);
1318                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1);
1319                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1);
1320
1321                 /* col_zero_flag */
1322                 if(!IS_INTRA(mb_type_col) && (   l1ref0[x8 + y8*h->b8_stride] == 0
1323                                               || (l1ref0[x8 + y8*h->b8_stride] < 0 && l1ref1[x8 + y8*h->b8_stride] == 0
1324                                                   && (h->x264_build>33 || !h->x264_build)))){
1325                     const int16_t (*l1mv)[2]= l1ref0[x8 + y8*h->b8_stride] == 0 ? l1mv0 : l1mv1;
1326                     if(IS_SUB_8X8(sub_mb_type)){
1327                         const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
1328                         if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
1329                             if(ref[0] == 0)
1330                                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1331                             if(ref[1] == 0)
1332                                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1333                         }
1334                     }else
1335                     for(i4=0; i4<4; i4++){
1336                         const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
1337                         if(ABS(mv_col[0]) <= 1 && ABS(mv_col[1]) <= 1){
1338                             if(ref[0] == 0)
1339                                 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
1340                             if(ref[1] == 0)
1341                                 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
1342                         }
1343                     }
1344                 }
1345             }
1346         }
1347     }else{ /* direct temporal mv pred */
1348         if(IS_16X16(*mb_type)){
1349             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
1350             if(IS_INTRA(mb_type_col)){
1351                 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
1352                 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
1353                 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
1354             }else{
1355                 const int ref0 = l1ref0[0] >= 0 ? h->map_col_to_list0[0][l1ref0[0]]
1356                                                 : h->map_col_to_list0[1][l1ref1[0]];
1357                 const int dist_scale_factor = h->dist_scale_factor[ref0];
1358                 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
1359                 int mv_l0[2];
1360                 mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8;
1361                 mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8;
1362                 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref0, 1);
1363                 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0],mv_l0[1]), 4);
1364                 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]), 4);
1365             }
1366         }else{
1367             for(i8=0; i8<4; i8++){
1368                 const int x8 = i8&1;
1369                 const int y8 = i8>>1;
1370                 int ref0, dist_scale_factor;
1371                 const int16_t (*l1mv)[2]= l1mv0;
1372
1373                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
1374                     continue;
1375                 h->sub_mb_type[i8] = sub_mb_type;
1376                 if(IS_INTRA(mb_type_col)){
1377                     fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1);
1378                     fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1379                     fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
1380                     fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
1381                     continue;
1382                 }
1383
1384                 ref0 = l1ref0[x8 + y8*h->b8_stride];
1385                 if(ref0 >= 0)
1386                     ref0 = h->map_col_to_list0[0][ref0];
1387                 else{
1388                     ref0 = h->map_col_to_list0[1][l1ref1[x8 + y8*h->b8_stride]];
1389                     l1mv= l1mv1;
1390                 }
1391                 dist_scale_factor = h->dist_scale_factor[ref0];
1392
1393                 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1);
1394                 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1);
1395                 if(IS_SUB_8X8(sub_mb_type)){
1396                     const int16_t *mv_col = l1mv[x8*3 + y8*3*h->b_stride];
1397                     int mx = (dist_scale_factor * mv_col[0] + 128) >> 8;
1398                     int my = (dist_scale_factor * mv_col[1] + 128) >> 8;
1399                     fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4);
1400                     fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4);
1401                 }else
1402                 for(i4=0; i4<4; i4++){
1403                     const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*h->b_stride];
1404                     int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]];
1405                     mv_l0[0] = (dist_scale_factor * mv_col[0] + 128) >> 8;
1406                     mv_l0[1] = (dist_scale_factor * mv_col[1] + 128) >> 8;
1407                     *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] =
1408                         pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]);
1409                 }
1410             }
1411         }
1412     }
1413 }
1414
1415 static inline void write_back_motion(H264Context *h, int mb_type){
1416     MpegEncContext * const s = &h->s;
1417     const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
1418     const int b8_xy= 2*s->mb_x + 2*s->mb_y*h->b8_stride;
1419     int list;
1420
1421     for(list=0; list<2; list++){
1422         int y;
1423         if(!USES_LIST(mb_type, list)){
1424             if(1){ //FIXME skip or never read if mb_type doesn't use it
1425                 for(y=0; y<4; y++){
1426                     *(uint64_t*)s->current_picture.motion_val[list][b_xy + 0 + y*h->b_stride]=
1427                     *(uint64_t*)s->current_picture.motion_val[list][b_xy + 2 + y*h->b_stride]= 0;
1428                 }
1429                 if( h->pps.cabac ) {
1430                     /* FIXME needed ? */
1431                     for(y=0; y<4; y++){
1432                         *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]=
1433                         *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= 0;
1434                     }
1435                 }
1436                 for(y=0; y<2; y++){
1437                     s->current_picture.ref_index[list][b8_xy + 0 + y*h->b8_stride]=
1438                     s->current_picture.ref_index[list][b8_xy + 1 + y*h->b8_stride]= LIST_NOT_USED;
1439                 }
1440             }
1441             continue;
1442         }
1443
1444         for(y=0; y<4; y++){
1445             *(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];
1446             *(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];
1447         }
1448         if( h->pps.cabac ) {
1449             for(y=0; y<4; y++){
1450                 *(uint64_t*)h->mvd_table[list][b_xy + 0 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+0 + 8*y];
1451                 *(uint64_t*)h->mvd_table[list][b_xy + 2 + y*h->b_stride]= *(uint64_t*)h->mvd_cache[list][scan8[0]+2 + 8*y];
1452             }
1453         }
1454         for(y=0; y<2; y++){
1455             s->current_picture.ref_index[list][b8_xy + 0 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+0 + 16*y];
1456             s->current_picture.ref_index[list][b8_xy + 1 + y*h->b8_stride]= h->ref_cache[list][scan8[0]+2 + 16*y];
1457         }
1458     }
1459
1460     if(h->slice_type == B_TYPE && h->pps.cabac){
1461         if(IS_8X8(mb_type)){
1462             h->direct_table[b8_xy+1+0*h->b8_stride] = IS_DIRECT(h->sub_mb_type[1]) ? 1 : 0;
1463             h->direct_table[b8_xy+0+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[2]) ? 1 : 0;
1464             h->direct_table[b8_xy+1+1*h->b8_stride] = IS_DIRECT(h->sub_mb_type[3]) ? 1 : 0;
1465         }
1466     }
1467 }
1468
1469 /**
1470  * Decodes a network abstraction layer unit.
1471  * @param consumed is the number of bytes used as input
1472  * @param length is the length of the array
1473  * @param dst_length is the number of decoded bytes FIXME here or a decode rbsp tailing?
1474  * @returns decoded bytes, might be src+1 if no escapes
1475  */
1476 static uint8_t *decode_nal(H264Context *h, uint8_t *src, int *dst_length, int *consumed, int length){
1477     int i, si, di;
1478     uint8_t *dst;
1479
1480 //    src[0]&0x80;                //forbidden bit
1481     h->nal_ref_idc= src[0]>>5;
1482     h->nal_unit_type= src[0]&0x1F;
1483
1484     src++; length--;
1485 #if 0
1486     for(i=0; i<length; i++)
1487         printf("%2X ", src[i]);
1488 #endif
1489     for(i=0; i+1<length; i+=2){
1490         if(src[i]) continue;
1491         if(i>0 && src[i-1]==0) i--;
1492         if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1493             if(src[i+2]!=3){
1494                 /* startcode, so we must be past the end */
1495                 length=i;
1496             }
1497             break;
1498         }
1499     }
1500
1501     if(i>=length-1){ //no escaped 0
1502         *dst_length= length;
1503         *consumed= length+1; //+1 for the header
1504         return src;
1505     }
1506
1507     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length);
1508     dst= h->rbsp_buffer;
1509
1510 //printf("decoding esc\n");
1511     si=di=0;
1512     while(si<length){
1513         //remove escapes (very rare 1:2^22)
1514         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1515             if(src[si+2]==3){ //escape
1516                 dst[di++]= 0;
1517                 dst[di++]= 0;
1518                 si+=3;
1519                 continue;
1520             }else //next start code
1521                 break;
1522         }
1523
1524         dst[di++]= src[si++];
1525     }
1526
1527     *dst_length= di;
1528     *consumed= si + 1;//+1 for the header
1529 //FIXME store exact number of bits in the getbitcontext (its needed for decoding)
1530     return dst;
1531 }
1532
1533 #if 0
1534 /**
1535  * @param src the data which should be escaped
1536  * @param dst the target buffer, dst+1 == src is allowed as a special case
1537  * @param length the length of the src data
1538  * @param dst_length the length of the dst array
1539  * @returns length of escaped data in bytes or -1 if an error occured
1540  */
1541 static int encode_nal(H264Context *h, uint8_t *dst, uint8_t *src, int length, int dst_length){
1542     int i, escape_count, si, di;
1543     uint8_t *temp;
1544
1545     assert(length>=0);
1546     assert(dst_length>0);
1547
1548     dst[0]= (h->nal_ref_idc<<5) + h->nal_unit_type;
1549
1550     if(length==0) return 1;
1551
1552     escape_count= 0;
1553     for(i=0; i<length; i+=2){
1554         if(src[i]) continue;
1555         if(i>0 && src[i-1]==0)
1556             i--;
1557         if(i+2<length && src[i+1]==0 && src[i+2]<=3){
1558             escape_count++;
1559             i+=2;
1560         }
1561     }
1562
1563     if(escape_count==0){
1564         if(dst+1 != src)
1565             memcpy(dst+1, src, length);
1566         return length + 1;
1567     }
1568
1569     if(length + escape_count + 1> dst_length)
1570         return -1;
1571
1572     //this should be damn rare (hopefully)
1573
1574     h->rbsp_buffer= av_fast_realloc(h->rbsp_buffer, &h->rbsp_buffer_size, length + escape_count);
1575     temp= h->rbsp_buffer;
1576 //printf("encoding esc\n");
1577
1578     si= 0;
1579     di= 0;
1580     while(si < length){
1581         if(si+2<length && src[si]==0 && src[si+1]==0 && src[si+2]<=3){
1582             temp[di++]= 0; si++;
1583             temp[di++]= 0; si++;
1584             temp[di++]= 3;
1585             temp[di++]= src[si++];
1586         }
1587         else
1588             temp[di++]= src[si++];
1589     }
1590     memcpy(dst+1, temp, length+escape_count);
1591
1592     assert(di == length+escape_count);
1593
1594     return di + 1;
1595 }
1596
1597 /**
1598  * write 1,10,100,1000,... for alignment, yes its exactly inverse to mpeg4
1599  */
1600 static void encode_rbsp_trailing(PutBitContext *pb){
1601     int length;
1602     put_bits(pb, 1, 1);
1603     length= (-put_bits_count(pb))&7;
1604     if(length) put_bits(pb, length, 0);
1605 }
1606 #endif
1607
1608 /**
1609  * identifies the exact end of the bitstream
1610  * @return the length of the trailing, or 0 if damaged
1611  */
1612 static int decode_rbsp_trailing(uint8_t *src){
1613     int v= *src;
1614     int r;
1615
1616     tprintf("rbsp trailing %X\n", v);
1617
1618     for(r=1; r<9; r++){
1619         if(v&1) return r;
1620         v>>=1;
1621     }
1622     return 0;
1623 }
1624
1625 /**
1626  * idct tranforms the 16 dc values and dequantize them.
1627  * @param qp quantization parameter
1628  */
1629 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1630 #define stride 16
1631     int i;
1632     int temp[16]; //FIXME check if this is a good idea
1633     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
1634     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1635
1636 //memset(block, 64, 2*256);
1637 //return;
1638     for(i=0; i<4; i++){
1639         const int offset= y_offset[i];
1640         const int z0= block[offset+stride*0] + block[offset+stride*4];
1641         const int z1= block[offset+stride*0] - block[offset+stride*4];
1642         const int z2= block[offset+stride*1] - block[offset+stride*5];
1643         const int z3= block[offset+stride*1] + block[offset+stride*5];
1644
1645         temp[4*i+0]= z0+z3;
1646         temp[4*i+1]= z1+z2;
1647         temp[4*i+2]= z1-z2;
1648         temp[4*i+3]= z0-z3;
1649     }
1650
1651     for(i=0; i<4; i++){
1652         const int offset= x_offset[i];
1653         const int z0= temp[4*0+i] + temp[4*2+i];
1654         const int z1= temp[4*0+i] - temp[4*2+i];
1655         const int z2= temp[4*1+i] - temp[4*3+i];
1656         const int z3= temp[4*1+i] + temp[4*3+i];
1657
1658         block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_resdual
1659         block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8));
1660         block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8));
1661         block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8));
1662     }
1663 }
1664
1665 #if 0
1666 /**
1667  * dct tranforms the 16 dc values.
1668  * @param qp quantization parameter ??? FIXME
1669  */
1670 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
1671 //    const int qmul= dequant_coeff[qp][0];
1672     int i;
1673     int temp[16]; //FIXME check if this is a good idea
1674     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
1675     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
1676
1677     for(i=0; i<4; i++){
1678         const int offset= y_offset[i];
1679         const int z0= block[offset+stride*0] + block[offset+stride*4];
1680         const int z1= block[offset+stride*0] - block[offset+stride*4];
1681         const int z2= block[offset+stride*1] - block[offset+stride*5];
1682         const int z3= block[offset+stride*1] + block[offset+stride*5];
1683
1684         temp[4*i+0]= z0+z3;
1685         temp[4*i+1]= z1+z2;
1686         temp[4*i+2]= z1-z2;
1687         temp[4*i+3]= z0-z3;
1688     }
1689
1690     for(i=0; i<4; i++){
1691         const int offset= x_offset[i];
1692         const int z0= temp[4*0+i] + temp[4*2+i];
1693         const int z1= temp[4*0+i] - temp[4*2+i];
1694         const int z2= temp[4*1+i] - temp[4*3+i];
1695         const int z3= temp[4*1+i] + temp[4*3+i];
1696
1697         block[stride*0 +offset]= (z0 + z3)>>1;
1698         block[stride*2 +offset]= (z1 + z2)>>1;
1699         block[stride*8 +offset]= (z1 - z2)>>1;
1700         block[stride*10+offset]= (z0 - z3)>>1;
1701     }
1702 }
1703 #endif
1704
1705 #undef xStride
1706 #undef stride
1707
1708 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){
1709     const int stride= 16*2;
1710     const int xStride= 16;
1711     int a,b,c,d,e;
1712
1713     a= block[stride*0 + xStride*0];
1714     b= block[stride*0 + xStride*1];
1715     c= block[stride*1 + xStride*0];
1716     d= block[stride*1 + xStride*1];
1717
1718     e= a-b;
1719     a= a+b;
1720     b= c-d;
1721     c= c+d;
1722
1723     block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7;
1724     block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7;
1725     block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7;
1726     block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7;
1727 }
1728
1729 #if 0
1730 static void chroma_dc_dct_c(DCTELEM *block){
1731     const int stride= 16*2;
1732     const int xStride= 16;
1733     int a,b,c,d,e;
1734
1735     a= block[stride*0 + xStride*0];
1736     b= block[stride*0 + xStride*1];
1737     c= block[stride*1 + xStride*0];
1738     d= block[stride*1 + xStride*1];
1739
1740     e= a-b;
1741     a= a+b;
1742     b= c-d;
1743     c= c+d;
1744
1745     block[stride*0 + xStride*0]= (a+c);
1746     block[stride*0 + xStride*1]= (e+b);
1747     block[stride*1 + xStride*0]= (a-c);
1748     block[stride*1 + xStride*1]= (e-b);
1749 }
1750 #endif
1751
1752 /**
1753  * gets the chroma qp.
1754  */
1755 static inline int get_chroma_qp(int chroma_qp_index_offset, int qscale){
1756
1757     return chroma_qp[clip(qscale + chroma_qp_index_offset, 0, 51)];
1758 }
1759
1760
1761 #if 0
1762 static void h264_diff_dct_c(DCTELEM *block, uint8_t *src1, uint8_t *src2, int stride){
1763     int i;
1764     //FIXME try int temp instead of block
1765
1766     for(i=0; i<4; i++){
1767         const int d0= src1[0 + i*stride] - src2[0 + i*stride];
1768         const int d1= src1[1 + i*stride] - src2[1 + i*stride];
1769         const int d2= src1[2 + i*stride] - src2[2 + i*stride];
1770         const int d3= src1[3 + i*stride] - src2[3 + i*stride];
1771         const int z0= d0 + d3;
1772         const int z3= d0 - d3;
1773         const int z1= d1 + d2;
1774         const int z2= d1 - d2;
1775
1776         block[0 + 4*i]=   z0 +   z1;
1777         block[1 + 4*i]= 2*z3 +   z2;
1778         block[2 + 4*i]=   z0 -   z1;
1779         block[3 + 4*i]=   z3 - 2*z2;
1780     }
1781
1782     for(i=0; i<4; i++){
1783         const int z0= block[0*4 + i] + block[3*4 + i];
1784         const int z3= block[0*4 + i] - block[3*4 + i];
1785         const int z1= block[1*4 + i] + block[2*4 + i];
1786         const int z2= block[1*4 + i] - block[2*4 + i];
1787
1788         block[0*4 + i]=   z0 +   z1;
1789         block[1*4 + i]= 2*z3 +   z2;
1790         block[2*4 + i]=   z0 -   z1;
1791         block[3*4 + i]=   z3 - 2*z2;
1792     }
1793 }
1794 #endif
1795
1796 //FIXME need to check that this doesnt overflow signed 32 bit for low qp, i am not sure, it's very close
1797 //FIXME check that gcc inlines this (and optimizes intra & seperate_dc stuff away)
1798 static inline int quantize_c(DCTELEM *block, uint8_t *scantable, int qscale, int intra, int seperate_dc){
1799     int i;
1800     const int * const quant_table= quant_coeff[qscale];
1801     const int bias= intra ? (1<<QUANT_SHIFT)/3 : (1<<QUANT_SHIFT)/6;
1802     const unsigned int threshold1= (1<<QUANT_SHIFT) - bias - 1;
1803     const unsigned int threshold2= (threshold1<<1);
1804     int last_non_zero;
1805
1806     if(seperate_dc){
1807         if(qscale<=18){
1808             //avoid overflows
1809             const int dc_bias= intra ? (1<<(QUANT_SHIFT-2))/3 : (1<<(QUANT_SHIFT-2))/6;
1810             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT-2)) - dc_bias - 1;
1811             const unsigned int dc_threshold2= (dc_threshold1<<1);
1812
1813             int level= block[0]*quant_coeff[qscale+18][0];
1814             if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1815                 if(level>0){
1816                     level= (dc_bias + level)>>(QUANT_SHIFT-2);
1817                     block[0]= level;
1818                 }else{
1819                     level= (dc_bias - level)>>(QUANT_SHIFT-2);
1820                     block[0]= -level;
1821                 }
1822 //                last_non_zero = i;
1823             }else{
1824                 block[0]=0;
1825             }
1826         }else{
1827             const int dc_bias= intra ? (1<<(QUANT_SHIFT+1))/3 : (1<<(QUANT_SHIFT+1))/6;
1828             const unsigned int dc_threshold1= (1<<(QUANT_SHIFT+1)) - dc_bias - 1;
1829             const unsigned int dc_threshold2= (dc_threshold1<<1);
1830
1831             int level= block[0]*quant_table[0];
1832             if(((unsigned)(level+dc_threshold1))>dc_threshold2){
1833                 if(level>0){
1834                     level= (dc_bias + level)>>(QUANT_SHIFT+1);
1835                     block[0]= level;
1836                 }else{
1837                     level= (dc_bias - level)>>(QUANT_SHIFT+1);
1838                     block[0]= -level;
1839                 }
1840 //                last_non_zero = i;
1841             }else{
1842                 block[0]=0;
1843             }
1844         }
1845         last_non_zero= 0;
1846         i=1;
1847     }else{
1848         last_non_zero= -1;
1849         i=0;
1850     }
1851
1852     for(; i<16; i++){
1853         const int j= scantable[i];
1854         int level= block[j]*quant_table[j];
1855
1856 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
1857 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
1858         if(((unsigned)(level+threshold1))>threshold2){
1859             if(level>0){
1860                 level= (bias + level)>>QUANT_SHIFT;
1861                 block[j]= level;
1862             }else{
1863                 level= (bias - level)>>QUANT_SHIFT;
1864                 block[j]= -level;
1865             }
1866             last_non_zero = i;
1867         }else{
1868             block[j]=0;
1869         }
1870     }
1871
1872     return last_non_zero;
1873 }
1874
1875 static void pred4x4_vertical_c(uint8_t *src, uint8_t *topright, int stride){
1876     const uint32_t a= ((uint32_t*)(src-stride))[0];
1877     ((uint32_t*)(src+0*stride))[0]= a;
1878     ((uint32_t*)(src+1*stride))[0]= a;
1879     ((uint32_t*)(src+2*stride))[0]= a;
1880     ((uint32_t*)(src+3*stride))[0]= a;
1881 }
1882
1883 static void pred4x4_horizontal_c(uint8_t *src, uint8_t *topright, int stride){
1884     ((uint32_t*)(src+0*stride))[0]= src[-1+0*stride]*0x01010101;
1885     ((uint32_t*)(src+1*stride))[0]= src[-1+1*stride]*0x01010101;
1886     ((uint32_t*)(src+2*stride))[0]= src[-1+2*stride]*0x01010101;
1887     ((uint32_t*)(src+3*stride))[0]= src[-1+3*stride]*0x01010101;
1888 }
1889
1890 static void pred4x4_dc_c(uint8_t *src, uint8_t *topright, int stride){
1891     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
1892                    + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
1893
1894     ((uint32_t*)(src+0*stride))[0]=
1895     ((uint32_t*)(src+1*stride))[0]=
1896     ((uint32_t*)(src+2*stride))[0]=
1897     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
1898 }
1899
1900 static void pred4x4_left_dc_c(uint8_t *src, uint8_t *topright, int stride){
1901     const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
1902
1903     ((uint32_t*)(src+0*stride))[0]=
1904     ((uint32_t*)(src+1*stride))[0]=
1905     ((uint32_t*)(src+2*stride))[0]=
1906     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
1907 }
1908
1909 static void pred4x4_top_dc_c(uint8_t *src, uint8_t *topright, int stride){
1910     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
1911
1912     ((uint32_t*)(src+0*stride))[0]=
1913     ((uint32_t*)(src+1*stride))[0]=
1914     ((uint32_t*)(src+2*stride))[0]=
1915     ((uint32_t*)(src+3*stride))[0]= dc* 0x01010101;
1916 }
1917
1918 static void pred4x4_128_dc_c(uint8_t *src, uint8_t *topright, int stride){
1919     ((uint32_t*)(src+0*stride))[0]=
1920     ((uint32_t*)(src+1*stride))[0]=
1921     ((uint32_t*)(src+2*stride))[0]=
1922     ((uint32_t*)(src+3*stride))[0]= 128U*0x01010101U;
1923 }
1924
1925
1926 #define LOAD_TOP_RIGHT_EDGE\
1927     const int t4= topright[0];\
1928     const int t5= topright[1];\
1929     const int t6= topright[2];\
1930     const int t7= topright[3];\
1931
1932 #define LOAD_LEFT_EDGE\
1933     const int l0= src[-1+0*stride];\
1934     const int l1= src[-1+1*stride];\
1935     const int l2= src[-1+2*stride];\
1936     const int l3= src[-1+3*stride];\
1937
1938 #define LOAD_TOP_EDGE\
1939     const int t0= src[ 0-1*stride];\
1940     const int t1= src[ 1-1*stride];\
1941     const int t2= src[ 2-1*stride];\
1942     const int t3= src[ 3-1*stride];\
1943
1944 static void pred4x4_down_right_c(uint8_t *src, uint8_t *topright, int stride){
1945     const int lt= src[-1-1*stride];
1946     LOAD_TOP_EDGE
1947     LOAD_LEFT_EDGE
1948
1949     src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
1950     src[0+2*stride]=
1951     src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
1952     src[0+1*stride]=
1953     src[1+2*stride]=
1954     src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
1955     src[0+0*stride]=
1956     src[1+1*stride]=
1957     src[2+2*stride]=
1958     src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
1959     src[1+0*stride]=
1960     src[2+1*stride]=
1961     src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
1962     src[2+0*stride]=
1963     src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
1964     src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
1965 }
1966
1967 static void pred4x4_down_left_c(uint8_t *src, uint8_t *topright, int stride){
1968     LOAD_TOP_EDGE
1969     LOAD_TOP_RIGHT_EDGE
1970 //    LOAD_LEFT_EDGE
1971
1972     src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
1973     src[1+0*stride]=
1974     src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
1975     src[2+0*stride]=
1976     src[1+1*stride]=
1977     src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
1978     src[3+0*stride]=
1979     src[2+1*stride]=
1980     src[1+2*stride]=
1981     src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
1982     src[3+1*stride]=
1983     src[2+2*stride]=
1984     src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
1985     src[3+2*stride]=
1986     src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
1987     src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
1988 }
1989
1990 static void pred4x4_vertical_right_c(uint8_t *src, uint8_t *topright, int stride){
1991     const int lt= src[-1-1*stride];
1992     LOAD_TOP_EDGE
1993     LOAD_LEFT_EDGE
1994     const __attribute__((unused)) int unu= l3;
1995
1996     src[0+0*stride]=
1997     src[1+2*stride]=(lt + t0 + 1)>>1;
1998     src[1+0*stride]=
1999     src[2+2*stride]=(t0 + t1 + 1)>>1;
2000     src[2+0*stride]=
2001     src[3+2*stride]=(t1 + t2 + 1)>>1;
2002     src[3+0*stride]=(t2 + t3 + 1)>>1;
2003     src[0+1*stride]=
2004     src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
2005     src[1+1*stride]=
2006     src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
2007     src[2+1*stride]=
2008     src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2009     src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
2010     src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
2011     src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2012 }
2013
2014 static void pred4x4_vertical_left_c(uint8_t *src, uint8_t *topright, int stride){
2015     LOAD_TOP_EDGE
2016     LOAD_TOP_RIGHT_EDGE
2017     const __attribute__((unused)) int unu= t7;
2018
2019     src[0+0*stride]=(t0 + t1 + 1)>>1;
2020     src[1+0*stride]=
2021     src[0+2*stride]=(t1 + t2 + 1)>>1;
2022     src[2+0*stride]=
2023     src[1+2*stride]=(t2 + t3 + 1)>>1;
2024     src[3+0*stride]=
2025     src[2+2*stride]=(t3 + t4+ 1)>>1;
2026     src[3+2*stride]=(t4 + t5+ 1)>>1;
2027     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2028     src[1+1*stride]=
2029     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
2030     src[2+1*stride]=
2031     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
2032     src[3+1*stride]=
2033     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
2034     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
2035 }
2036
2037 static void pred4x4_horizontal_up_c(uint8_t *src, uint8_t *topright, int stride){
2038     LOAD_LEFT_EDGE
2039
2040     src[0+0*stride]=(l0 + l1 + 1)>>1;
2041     src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2042     src[2+0*stride]=
2043     src[0+1*stride]=(l1 + l2 + 1)>>1;
2044     src[3+0*stride]=
2045     src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
2046     src[2+1*stride]=
2047     src[0+2*stride]=(l2 + l3 + 1)>>1;
2048     src[3+1*stride]=
2049     src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
2050     src[3+2*stride]=
2051     src[1+3*stride]=
2052     src[0+3*stride]=
2053     src[2+2*stride]=
2054     src[2+3*stride]=
2055     src[3+3*stride]=l3;
2056 }
2057
2058 static void pred4x4_horizontal_down_c(uint8_t *src, uint8_t *topright, int stride){
2059     const int lt= src[-1-1*stride];
2060     LOAD_TOP_EDGE
2061     LOAD_LEFT_EDGE
2062     const __attribute__((unused)) int unu= t3;
2063
2064     src[0+0*stride]=
2065     src[2+1*stride]=(lt + l0 + 1)>>1;
2066     src[1+0*stride]=
2067     src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
2068     src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
2069     src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
2070     src[0+1*stride]=
2071     src[2+2*stride]=(l0 + l1 + 1)>>1;
2072     src[1+1*stride]=
2073     src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
2074     src[0+2*stride]=
2075     src[2+3*stride]=(l1 + l2+ 1)>>1;
2076     src[1+2*stride]=
2077     src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
2078     src[0+3*stride]=(l2 + l3 + 1)>>1;
2079     src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
2080 }
2081
2082 static void pred16x16_vertical_c(uint8_t *src, int stride){
2083     int i;
2084     const uint32_t a= ((uint32_t*)(src-stride))[0];
2085     const uint32_t b= ((uint32_t*)(src-stride))[1];
2086     const uint32_t c= ((uint32_t*)(src-stride))[2];
2087     const uint32_t d= ((uint32_t*)(src-stride))[3];
2088
2089     for(i=0; i<16; i++){
2090         ((uint32_t*)(src+i*stride))[0]= a;
2091         ((uint32_t*)(src+i*stride))[1]= b;
2092         ((uint32_t*)(src+i*stride))[2]= c;
2093         ((uint32_t*)(src+i*stride))[3]= d;
2094     }
2095 }
2096
2097 static void pred16x16_horizontal_c(uint8_t *src, int stride){
2098     int i;
2099
2100     for(i=0; i<16; i++){
2101         ((uint32_t*)(src+i*stride))[0]=
2102         ((uint32_t*)(src+i*stride))[1]=
2103         ((uint32_t*)(src+i*stride))[2]=
2104         ((uint32_t*)(src+i*stride))[3]= src[-1+i*stride]*0x01010101;
2105     }
2106 }
2107
2108 static void pred16x16_dc_c(uint8_t *src, int stride){
2109     int i, dc=0;
2110
2111     for(i=0;i<16; i++){
2112         dc+= src[-1+i*stride];
2113     }
2114
2115     for(i=0;i<16; i++){
2116         dc+= src[i-stride];
2117     }
2118
2119     dc= 0x01010101*((dc + 16)>>5);
2120
2121     for(i=0; i<16; i++){
2122         ((uint32_t*)(src+i*stride))[0]=
2123         ((uint32_t*)(src+i*stride))[1]=
2124         ((uint32_t*)(src+i*stride))[2]=
2125         ((uint32_t*)(src+i*stride))[3]= dc;
2126     }
2127 }
2128
2129 static void pred16x16_left_dc_c(uint8_t *src, int stride){
2130     int i, dc=0;
2131
2132     for(i=0;i<16; i++){
2133         dc+= src[-1+i*stride];
2134     }
2135
2136     dc= 0x01010101*((dc + 8)>>4);
2137
2138     for(i=0; i<16; i++){
2139         ((uint32_t*)(src+i*stride))[0]=
2140         ((uint32_t*)(src+i*stride))[1]=
2141         ((uint32_t*)(src+i*stride))[2]=
2142         ((uint32_t*)(src+i*stride))[3]= dc;
2143     }
2144 }
2145
2146 static void pred16x16_top_dc_c(uint8_t *src, int stride){
2147     int i, dc=0;
2148
2149     for(i=0;i<16; i++){
2150         dc+= src[i-stride];
2151     }
2152     dc= 0x01010101*((dc + 8)>>4);
2153
2154     for(i=0; i<16; i++){
2155         ((uint32_t*)(src+i*stride))[0]=
2156         ((uint32_t*)(src+i*stride))[1]=
2157         ((uint32_t*)(src+i*stride))[2]=
2158         ((uint32_t*)(src+i*stride))[3]= dc;
2159     }
2160 }
2161
2162 static void pred16x16_128_dc_c(uint8_t *src, int stride){
2163     int i;
2164
2165     for(i=0; i<16; i++){
2166         ((uint32_t*)(src+i*stride))[0]=
2167         ((uint32_t*)(src+i*stride))[1]=
2168         ((uint32_t*)(src+i*stride))[2]=
2169         ((uint32_t*)(src+i*stride))[3]= 0x01010101U*128U;
2170     }
2171 }
2172
2173 static inline void pred16x16_plane_compat_c(uint8_t *src, int stride, const int svq3){
2174   int i, j, k;
2175   int a;
2176   uint8_t *cm = cropTbl + MAX_NEG_CROP;
2177   const uint8_t * const src0 = src+7-stride;
2178   const uint8_t *src1 = src+8*stride-1;
2179   const uint8_t *src2 = src1-2*stride;      // == src+6*stride-1;
2180   int H = src0[1] - src0[-1];
2181   int V = src1[0] - src2[ 0];
2182   for(k=2; k<=8; ++k) {
2183     src1 += stride; src2 -= stride;
2184     H += k*(src0[k] - src0[-k]);
2185     V += k*(src1[0] - src2[ 0]);
2186   }
2187   if(svq3){
2188     H = ( 5*(H/4) ) / 16;
2189     V = ( 5*(V/4) ) / 16;
2190
2191     /* required for 100% accuracy */
2192     i = H; H = V; V = i;
2193   }else{
2194     H = ( 5*H+32 ) >> 6;
2195     V = ( 5*V+32 ) >> 6;
2196   }
2197
2198   a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
2199   for(j=16; j>0; --j) {
2200     int b = a;
2201     a += V;
2202     for(i=-16; i<0; i+=4) {
2203       src[16+i] = cm[ (b    ) >> 5 ];
2204       src[17+i] = cm[ (b+  H) >> 5 ];
2205       src[18+i] = cm[ (b+2*H) >> 5 ];
2206       src[19+i] = cm[ (b+3*H) >> 5 ];
2207       b += 4*H;
2208     }
2209     src += stride;
2210   }
2211 }
2212
2213 static void pred16x16_plane_c(uint8_t *src, int stride){
2214     pred16x16_plane_compat_c(src, stride, 0);
2215 }
2216
2217 static void pred8x8_vertical_c(uint8_t *src, int stride){
2218     int i;
2219     const uint32_t a= ((uint32_t*)(src-stride))[0];
2220     const uint32_t b= ((uint32_t*)(src-stride))[1];
2221
2222     for(i=0; i<8; i++){
2223         ((uint32_t*)(src+i*stride))[0]= a;
2224         ((uint32_t*)(src+i*stride))[1]= b;
2225     }
2226 }
2227
2228 static void pred8x8_horizontal_c(uint8_t *src, int stride){
2229     int i;
2230
2231     for(i=0; i<8; i++){
2232         ((uint32_t*)(src+i*stride))[0]=
2233         ((uint32_t*)(src+i*stride))[1]= src[-1+i*stride]*0x01010101;
2234     }
2235 }
2236
2237 static void pred8x8_128_dc_c(uint8_t *src, int stride){
2238     int i;
2239
2240     for(i=0; i<8; i++){
2241         ((uint32_t*)(src+i*stride))[0]=
2242         ((uint32_t*)(src+i*stride))[1]= 0x01010101U*128U;
2243     }
2244 }
2245
2246 static void pred8x8_left_dc_c(uint8_t *src, int stride){
2247     int i;
2248     int dc0, dc2;
2249
2250     dc0=dc2=0;
2251     for(i=0;i<4; i++){
2252         dc0+= src[-1+i*stride];
2253         dc2+= src[-1+(i+4)*stride];
2254     }
2255     dc0= 0x01010101*((dc0 + 2)>>2);
2256     dc2= 0x01010101*((dc2 + 2)>>2);
2257
2258     for(i=0; i<4; i++){
2259         ((uint32_t*)(src+i*stride))[0]=
2260         ((uint32_t*)(src+i*stride))[1]= dc0;
2261     }
2262     for(i=4; i<8; i++){
2263         ((uint32_t*)(src+i*stride))[0]=
2264         ((uint32_t*)(src+i*stride))[1]= dc2;
2265     }
2266 }
2267
2268 static void pred8x8_top_dc_c(uint8_t *src, int stride){
2269     int i;
2270     int dc0, dc1;
2271
2272     dc0=dc1=0;
2273     for(i=0;i<4; i++){
2274         dc0+= src[i-stride];
2275         dc1+= src[4+i-stride];
2276     }
2277     dc0= 0x01010101*((dc0 + 2)>>2);
2278     dc1= 0x01010101*((dc1 + 2)>>2);
2279
2280     for(i=0; i<4; i++){
2281         ((uint32_t*)(src+i*stride))[0]= dc0;
2282         ((uint32_t*)(src+i*stride))[1]= dc1;
2283     }
2284     for(i=4; i<8; i++){
2285         ((uint32_t*)(src+i*stride))[0]= dc0;
2286         ((uint32_t*)(src+i*stride))[1]= dc1;
2287     }
2288 }
2289
2290
2291 static void pred8x8_dc_c(uint8_t *src, int stride){
2292     int i;
2293     int dc0, dc1, dc2, dc3;
2294
2295     dc0=dc1=dc2=0;
2296     for(i=0;i<4; i++){
2297         dc0+= src[-1+i*stride] + src[i-stride];
2298         dc1+= src[4+i-stride];
2299         dc2+= src[-1+(i+4)*stride];
2300     }
2301     dc3= 0x01010101*((dc1 + dc2 + 4)>>3);
2302     dc0= 0x01010101*((dc0 + 4)>>3);
2303     dc1= 0x01010101*((dc1 + 2)>>2);
2304     dc2= 0x01010101*((dc2 + 2)>>2);
2305
2306     for(i=0; i<4; i++){
2307         ((uint32_t*)(src+i*stride))[0]= dc0;
2308         ((uint32_t*)(src+i*stride))[1]= dc1;
2309     }
2310     for(i=4; i<8; i++){
2311         ((uint32_t*)(src+i*stride))[0]= dc2;
2312         ((uint32_t*)(src+i*stride))[1]= dc3;
2313     }
2314 }
2315
2316 static void pred8x8_plane_c(uint8_t *src, int stride){
2317   int j, k;
2318   int a;
2319   uint8_t *cm = cropTbl + MAX_NEG_CROP;
2320   const uint8_t * const src0 = src+3-stride;
2321   const uint8_t *src1 = src+4*stride-1;
2322   const uint8_t *src2 = src1-2*stride;      // == src+2*stride-1;
2323   int H = src0[1] - src0[-1];
2324   int V = src1[0] - src2[ 0];
2325   for(k=2; k<=4; ++k) {
2326     src1 += stride; src2 -= stride;
2327     H += k*(src0[k] - src0[-k]);
2328     V += k*(src1[0] - src2[ 0]);
2329   }
2330   H = ( 17*H+16 ) >> 5;
2331   V = ( 17*V+16 ) >> 5;
2332
2333   a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
2334   for(j=8; j>0; --j) {
2335     int b = a;
2336     a += V;
2337     src[0] = cm[ (b    ) >> 5 ];
2338     src[1] = cm[ (b+  H) >> 5 ];
2339     src[2] = cm[ (b+2*H) >> 5 ];
2340     src[3] = cm[ (b+3*H) >> 5 ];
2341     src[4] = cm[ (b+4*H) >> 5 ];
2342     src[5] = cm[ (b+5*H) >> 5 ];
2343     src[6] = cm[ (b+6*H) >> 5 ];
2344     src[7] = cm[ (b+7*H) >> 5 ];
2345     src += stride;
2346   }
2347 }
2348
2349 #define SRC(x,y) src[(x)+(y)*stride]
2350 #define PL(y) \
2351     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
2352 #define PREDICT_8x8_LOAD_LEFT \
2353     const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
2354                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
2355     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
2356     const int l7 attribute_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
2357
2358 #define PT(x) \
2359     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
2360 #define PREDICT_8x8_LOAD_TOP \
2361     const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
2362                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
2363     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
2364     const int t7 attribute_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
2365                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
2366
2367 #define PTR(x) \
2368     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
2369 #define PREDICT_8x8_LOAD_TOPRIGHT \
2370     int t8, t9, t10, t11, t12, t13, t14, t15; \
2371     if(has_topright) { \
2372         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
2373         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
2374     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
2375
2376 #define PREDICT_8x8_LOAD_TOPLEFT \
2377     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
2378
2379 #define PREDICT_8x8_DC(v) \
2380     int y; \
2381     for( y = 0; y < 8; y++ ) { \
2382         ((uint32_t*)src)[0] = \
2383         ((uint32_t*)src)[1] = v; \
2384         src += stride; \
2385     }
2386
2387 static void pred8x8l_128_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2388 {
2389     PREDICT_8x8_DC(0x80808080);
2390 }
2391 static void pred8x8l_left_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2392 {
2393     PREDICT_8x8_LOAD_LEFT;
2394     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3) * 0x01010101;
2395     PREDICT_8x8_DC(dc);
2396 }
2397 static void pred8x8l_top_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2398 {
2399     PREDICT_8x8_LOAD_TOP;
2400     const uint32_t dc = ((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3) * 0x01010101;
2401     PREDICT_8x8_DC(dc);
2402 }
2403 static void pred8x8l_dc_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2404 {
2405     PREDICT_8x8_LOAD_LEFT;
2406     PREDICT_8x8_LOAD_TOP;
2407     const uint32_t dc = ((l0+l1+l2+l3+l4+l5+l6+l7
2408                          +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4) * 0x01010101;
2409     PREDICT_8x8_DC(dc);
2410 }
2411 static void pred8x8l_horizontal_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2412 {
2413     PREDICT_8x8_LOAD_LEFT;
2414 #define ROW(y) ((uint32_t*)(src+y*stride))[0] =\
2415                ((uint32_t*)(src+y*stride))[1] = 0x01010101 * l##y
2416     ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
2417 #undef ROW
2418 }
2419 static void pred8x8l_vertical_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2420 {
2421     int y;
2422     PREDICT_8x8_LOAD_TOP;
2423     src[0] = t0;
2424     src[1] = t1;
2425     src[2] = t2;
2426     src[3] = t3;
2427     src[4] = t4;
2428     src[5] = t5;
2429     src[6] = t6;
2430     src[7] = t7;
2431     for( y = 1; y < 8; y++ )
2432         *(uint64_t*)(src+y*stride) = *(uint64_t*)src;
2433 }
2434 static void pred8x8l_down_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2435 {
2436     PREDICT_8x8_LOAD_TOP;
2437     PREDICT_8x8_LOAD_TOPRIGHT;
2438     SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
2439     SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
2440     SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
2441     SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
2442     SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
2443     SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
2444     SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;
2445     SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;
2446     SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;
2447     SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
2448     SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
2449     SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
2450     SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
2451     SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
2452     SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
2453 }
2454 static void pred8x8l_down_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2455 {
2456     PREDICT_8x8_LOAD_TOP;
2457     PREDICT_8x8_LOAD_LEFT;
2458     PREDICT_8x8_LOAD_TOPLEFT;
2459     SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
2460     SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
2461     SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
2462     SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
2463     SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
2464     SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
2465     SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;
2466     SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;
2467     SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;
2468     SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
2469     SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
2470     SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
2471     SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
2472     SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
2473     SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
2474
2475 }
2476 static void pred8x8l_vertical_right_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2477 {
2478     PREDICT_8x8_LOAD_TOP;
2479     PREDICT_8x8_LOAD_LEFT;
2480     PREDICT_8x8_LOAD_TOPLEFT;
2481     SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
2482     SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
2483     SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
2484     SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
2485     SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
2486     SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
2487     SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
2488     SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
2489     SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
2490     SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
2491     SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
2492     SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
2493     SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
2494     SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
2495     SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
2496     SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
2497     SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
2498     SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
2499     SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
2500     SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
2501     SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
2502     SRC(7,0)= (t6 + t7 + 1) >> 1;
2503 }
2504 static void pred8x8l_horizontal_down_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2505 {
2506     PREDICT_8x8_LOAD_TOP;
2507     PREDICT_8x8_LOAD_LEFT;
2508     PREDICT_8x8_LOAD_TOPLEFT;
2509     SRC(0,7)= (l6 + l7 + 1) >> 1;
2510     SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
2511     SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
2512     SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
2513     SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
2514     SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
2515     SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
2516     SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
2517     SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
2518     SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
2519     SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
2520     SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
2521     SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
2522     SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
2523     SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
2524     SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
2525     SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
2526     SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
2527     SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
2528     SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
2529     SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
2530     SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
2531 }
2532 static void pred8x8l_vertical_left_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2533 {
2534     PREDICT_8x8_LOAD_TOP;
2535     PREDICT_8x8_LOAD_TOPRIGHT;
2536     SRC(0,0)= (t0 + t1 + 1) >> 1;
2537     SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
2538     SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
2539     SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
2540     SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
2541     SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
2542     SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
2543     SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
2544     SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
2545     SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
2546     SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
2547     SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
2548     SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
2549     SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
2550     SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
2551     SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
2552     SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
2553     SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
2554     SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
2555     SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
2556     SRC(7,6)= (t10 + t11 + 1) >> 1;
2557     SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
2558 }
2559 static void pred8x8l_horizontal_up_c(uint8_t *src, int has_topleft, int has_topright, int stride)
2560 {
2561     PREDICT_8x8_LOAD_LEFT;
2562     SRC(0,0)= (l0 + l1 + 1) >> 1;
2563     SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
2564     SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
2565     SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
2566     SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
2567     SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
2568     SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
2569     SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
2570     SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
2571     SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
2572     SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
2573     SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
2574     SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
2575     SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
2576     SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
2577     SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
2578     SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
2579     SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
2580 }
2581 #undef PREDICT_8x8_LOAD_LEFT
2582 #undef PREDICT_8x8_LOAD_TOP
2583 #undef PREDICT_8x8_LOAD_TOPLEFT
2584 #undef PREDICT_8x8_LOAD_TOPRIGHT
2585 #undef PREDICT_8x8_DC
2586 #undef PTR
2587 #undef PT
2588 #undef PL
2589 #undef SRC
2590
2591 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list,
2592                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2593                            int src_x_offset, int src_y_offset,
2594                            qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){
2595     MpegEncContext * const s = &h->s;
2596     const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
2597     const int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
2598     const int luma_xy= (mx&3) + ((my&3)<<2);
2599     uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*s->linesize;
2600     uint8_t * src_cb= pic->data[1] + (mx>>3) + (my>>3)*s->uvlinesize;
2601     uint8_t * src_cr= pic->data[2] + (mx>>3) + (my>>3)*s->uvlinesize;
2602     int extra_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; //FIXME increase edge?, IMHO not worth it
2603     int extra_height= extra_width;
2604     int emu=0;
2605     const int full_mx= mx>>2;
2606     const int full_my= my>>2;
2607     const int pic_width  = 16*s->mb_width;
2608     const int pic_height = 16*s->mb_height;
2609
2610     assert(pic->data[0]);
2611
2612     if(mx&7) extra_width -= 3;
2613     if(my&7) extra_height -= 3;
2614
2615     if(   full_mx < 0-extra_width
2616        || full_my < 0-extra_height
2617        || full_mx + 16/*FIXME*/ > pic_width + extra_width
2618        || full_my + 16/*FIXME*/ > pic_height + extra_height){
2619         ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*s->linesize, s->linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
2620             src_y= s->edge_emu_buffer + 2 + 2*s->linesize;
2621         emu=1;
2622     }
2623
2624     qpix_op[luma_xy](dest_y, src_y, s->linesize); //FIXME try variable height perhaps?
2625     if(!square){
2626         qpix_op[luma_xy](dest_y + delta, src_y + delta, s->linesize);
2627     }
2628
2629     if(s->flags&CODEC_FLAG_GRAY) return;
2630
2631     if(emu){
2632         ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
2633             src_cb= s->edge_emu_buffer;
2634     }
2635     chroma_op(dest_cb, src_cb, s->uvlinesize, chroma_height, mx&7, my&7);
2636
2637     if(emu){
2638         ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, s->uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
2639             src_cr= s->edge_emu_buffer;
2640     }
2641     chroma_op(dest_cr, src_cr, s->uvlinesize, chroma_height, mx&7, my&7);
2642 }
2643
2644 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta,
2645                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2646                            int x_offset, int y_offset,
2647                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2648                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
2649                            int list0, int list1){
2650     MpegEncContext * const s = &h->s;
2651     qpel_mc_func *qpix_op=  qpix_put;
2652     h264_chroma_mc_func chroma_op= chroma_put;
2653
2654     dest_y  += 2*x_offset + 2*y_offset*s->  linesize;
2655     dest_cb +=   x_offset +   y_offset*s->uvlinesize;
2656     dest_cr +=   x_offset +   y_offset*s->uvlinesize;
2657     x_offset += 8*s->mb_x;
2658     y_offset += 8*s->mb_y;
2659
2660     if(list0){
2661         Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
2662         mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
2663                            dest_y, dest_cb, dest_cr, x_offset, y_offset,
2664                            qpix_op, chroma_op);
2665
2666         qpix_op=  qpix_avg;
2667         chroma_op= chroma_avg;
2668     }
2669
2670     if(list1){
2671         Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
2672         mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
2673                            dest_y, dest_cb, dest_cr, x_offset, y_offset,
2674                            qpix_op, chroma_op);
2675     }
2676 }
2677
2678 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta,
2679                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2680                            int x_offset, int y_offset,
2681                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2682                            h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
2683                            h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
2684                            int list0, int list1){
2685     MpegEncContext * const s = &h->s;
2686
2687     dest_y  += 2*x_offset + 2*y_offset*s->  linesize;
2688     dest_cb +=   x_offset +   y_offset*s->uvlinesize;
2689     dest_cr +=   x_offset +   y_offset*s->uvlinesize;
2690     x_offset += 8*s->mb_x;
2691     y_offset += 8*s->mb_y;
2692
2693     if(list0 && list1){
2694         /* don't optimize for luma-only case, since B-frames usually
2695          * use implicit weights => chroma too. */
2696         uint8_t *tmp_cb = s->obmc_scratchpad;
2697         uint8_t *tmp_cr = tmp_cb + 8*s->uvlinesize;
2698         uint8_t *tmp_y  = tmp_cr + 8*s->uvlinesize;
2699         int refn0 = h->ref_cache[0][ scan8[n] ];
2700         int refn1 = h->ref_cache[1][ scan8[n] ];
2701
2702         mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
2703                     dest_y, dest_cb, dest_cr,
2704                     x_offset, y_offset, qpix_put, chroma_put);
2705         mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
2706                     tmp_y, tmp_cb, tmp_cr,
2707                     x_offset, y_offset, qpix_put, chroma_put);
2708
2709         if(h->use_weight == 2){
2710             int weight0 = h->implicit_weight[refn0][refn1];
2711             int weight1 = 64 - weight0;
2712             luma_weight_avg(  dest_y,  tmp_y,  s->  linesize, 5, weight0, weight1, 0, 0);
2713             chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, 5, weight0, weight1, 0, 0);
2714             chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, 5, weight0, weight1, 0, 0);
2715         }else{
2716             luma_weight_avg(dest_y, tmp_y, s->linesize, h->luma_log2_weight_denom,
2717                             h->luma_weight[0][refn0], h->luma_weight[1][refn1],
2718                             h->luma_offset[0][refn0], h->luma_offset[1][refn1]);
2719             chroma_weight_avg(dest_cb, tmp_cb, s->uvlinesize, h->chroma_log2_weight_denom,
2720                             h->chroma_weight[0][refn0][0], h->chroma_weight[1][refn1][0],
2721                             h->chroma_offset[0][refn0][0], h->chroma_offset[1][refn1][0]);
2722             chroma_weight_avg(dest_cr, tmp_cr, s->uvlinesize, h->chroma_log2_weight_denom,
2723                             h->chroma_weight[0][refn0][1], h->chroma_weight[1][refn1][1],
2724                             h->chroma_offset[0][refn0][1], h->chroma_offset[1][refn1][1]);
2725         }
2726     }else{
2727         int list = list1 ? 1 : 0;
2728         int refn = h->ref_cache[list][ scan8[n] ];
2729         Picture *ref= &h->ref_list[list][refn];
2730         mc_dir_part(h, ref, n, square, chroma_height, delta, list,
2731                     dest_y, dest_cb, dest_cr, x_offset, y_offset,
2732                     qpix_put, chroma_put);
2733
2734         luma_weight_op(dest_y, s->linesize, h->luma_log2_weight_denom,
2735                        h->luma_weight[list][refn], h->luma_offset[list][refn]);
2736         if(h->use_weight_chroma){
2737             chroma_weight_op(dest_cb, s->uvlinesize, h->chroma_log2_weight_denom,
2738                              h->chroma_weight[list][refn][0], h->chroma_offset[list][refn][0]);
2739             chroma_weight_op(dest_cr, s->uvlinesize, h->chroma_log2_weight_denom,
2740                              h->chroma_weight[list][refn][1], h->chroma_offset[list][refn][1]);
2741         }
2742     }
2743 }
2744
2745 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta,
2746                            uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2747                            int x_offset, int y_offset,
2748                            qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put,
2749                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
2750                            h264_weight_func *weight_op, h264_biweight_func *weight_avg,
2751                            int list0, int list1){
2752     if((h->use_weight==2 && list0 && list1
2753         && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ] != 32))
2754        || h->use_weight==1)
2755         mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
2756                          x_offset, y_offset, qpix_put, chroma_put,
2757                          weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1);
2758     else
2759         mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
2760                     x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1);
2761 }
2762
2763 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
2764                       qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put),
2765                       qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg),
2766                       h264_weight_func *weight_op, h264_biweight_func *weight_avg){
2767     MpegEncContext * const s = &h->s;
2768     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
2769     const int mb_type= s->current_picture.mb_type[mb_xy];
2770
2771     assert(IS_INTER(mb_type));
2772
2773     if(IS_16X16(mb_type)){
2774         mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
2775                 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
2776                 &weight_op[0], &weight_avg[0],
2777                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2778     }else if(IS_16X8(mb_type)){
2779         mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0,
2780                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2781                 &weight_op[1], &weight_avg[1],
2782                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2783         mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4,
2784                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
2785                 &weight_op[1], &weight_avg[1],
2786                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2787     }else if(IS_8X16(mb_type)){
2788         mc_part(h, 0, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 0, 0,
2789                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2790                 &weight_op[2], &weight_avg[2],
2791                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
2792         mc_part(h, 4, 0, 8, 8*s->linesize, dest_y, dest_cb, dest_cr, 4, 0,
2793                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2794                 &weight_op[2], &weight_avg[2],
2795                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
2796     }else{
2797         int i;
2798
2799         assert(IS_8X8(mb_type));
2800
2801         for(i=0; i<4; i++){
2802             const int sub_mb_type= h->sub_mb_type[i];
2803             const int n= 4*i;
2804             int x_offset= (i&1)<<2;
2805             int y_offset= (i&2)<<1;
2806
2807             if(IS_SUB_8X8(sub_mb_type)){
2808                 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2809                     qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
2810                     &weight_op[3], &weight_avg[3],
2811                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2812             }else if(IS_SUB_8X4(sub_mb_type)){
2813                 mc_part(h, n  , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2814                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
2815                     &weight_op[4], &weight_avg[4],
2816                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2817                 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
2818                     qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
2819                     &weight_op[4], &weight_avg[4],
2820                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2821             }else if(IS_SUB_4X8(sub_mb_type)){
2822                 mc_part(h, n  , 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
2823                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2824                     &weight_op[5], &weight_avg[5],
2825                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2826                 mc_part(h, n+1, 0, 4, 4*s->linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
2827                     qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2828                     &weight_op[5], &weight_avg[5],
2829                     IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2830             }else{
2831                 int j;
2832                 assert(IS_SUB_4X4(sub_mb_type));
2833                 for(j=0; j<4; j++){
2834                     int sub_x_offset= x_offset + 2*(j&1);
2835                     int sub_y_offset= y_offset +   (j&2);
2836                     mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
2837                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
2838                         &weight_op[6], &weight_avg[6],
2839                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
2840                 }
2841             }
2842         }
2843     }
2844 }
2845
2846 static void decode_init_vlc(H264Context *h){
2847     static int done = 0;
2848
2849     if (!done) {
2850         int i;
2851         done = 1;
2852
2853         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
2854                  &chroma_dc_coeff_token_len [0], 1, 1,
2855                  &chroma_dc_coeff_token_bits[0], 1, 1, 1);
2856
2857         for(i=0; i<4; i++){
2858             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
2859                      &coeff_token_len [i][0], 1, 1,
2860                      &coeff_token_bits[i][0], 1, 1, 1);
2861         }
2862
2863         for(i=0; i<3; i++){
2864             init_vlc(&chroma_dc_total_zeros_vlc[i], CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
2865                      &chroma_dc_total_zeros_len [i][0], 1, 1,
2866                      &chroma_dc_total_zeros_bits[i][0], 1, 1, 1);
2867         }
2868         for(i=0; i<15; i++){
2869             init_vlc(&total_zeros_vlc[i], TOTAL_ZEROS_VLC_BITS, 16,
2870                      &total_zeros_len [i][0], 1, 1,
2871                      &total_zeros_bits[i][0], 1, 1, 1);
2872         }
2873
2874         for(i=0; i<6; i++){
2875             init_vlc(&run_vlc[i], RUN_VLC_BITS, 7,
2876                      &run_len [i][0], 1, 1,
2877                      &run_bits[i][0], 1, 1, 1);
2878         }
2879         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
2880                  &run_len [6][0], 1, 1,
2881                  &run_bits[6][0], 1, 1, 1);
2882     }
2883 }
2884
2885 /**
2886  * Sets the intra prediction function pointers.
2887  */
2888 static void init_pred_ptrs(H264Context *h){
2889 //    MpegEncContext * const s = &h->s;
2890
2891     h->pred4x4[VERT_PRED           ]= pred4x4_vertical_c;
2892     h->pred4x4[HOR_PRED            ]= pred4x4_horizontal_c;
2893     h->pred4x4[DC_PRED             ]= pred4x4_dc_c;
2894     h->pred4x4[DIAG_DOWN_LEFT_PRED ]= pred4x4_down_left_c;
2895     h->pred4x4[DIAG_DOWN_RIGHT_PRED]= pred4x4_down_right_c;
2896     h->pred4x4[VERT_RIGHT_PRED     ]= pred4x4_vertical_right_c;
2897     h->pred4x4[HOR_DOWN_PRED       ]= pred4x4_horizontal_down_c;
2898     h->pred4x4[VERT_LEFT_PRED      ]= pred4x4_vertical_left_c;
2899     h->pred4x4[HOR_UP_PRED         ]= pred4x4_horizontal_up_c;
2900     h->pred4x4[LEFT_DC_PRED        ]= pred4x4_left_dc_c;
2901     h->pred4x4[TOP_DC_PRED         ]= pred4x4_top_dc_c;
2902     h->pred4x4[DC_128_PRED         ]= pred4x4_128_dc_c;
2903
2904     h->pred8x8l[VERT_PRED           ]= pred8x8l_vertical_c;
2905     h->pred8x8l[HOR_PRED            ]= pred8x8l_horizontal_c;
2906     h->pred8x8l[DC_PRED             ]= pred8x8l_dc_c;
2907     h->pred8x8l[DIAG_DOWN_LEFT_PRED ]= pred8x8l_down_left_c;
2908     h->pred8x8l[DIAG_DOWN_RIGHT_PRED]= pred8x8l_down_right_c;
2909     h->pred8x8l[VERT_RIGHT_PRED     ]= pred8x8l_vertical_right_c;
2910     h->pred8x8l[HOR_DOWN_PRED       ]= pred8x8l_horizontal_down_c;
2911     h->pred8x8l[VERT_LEFT_PRED      ]= pred8x8l_vertical_left_c;
2912     h->pred8x8l[HOR_UP_PRED         ]= pred8x8l_horizontal_up_c;
2913     h->pred8x8l[LEFT_DC_PRED        ]= pred8x8l_left_dc_c;
2914     h->pred8x8l[TOP_DC_PRED         ]= pred8x8l_top_dc_c;
2915     h->pred8x8l[DC_128_PRED         ]= pred8x8l_128_dc_c;
2916
2917     h->pred8x8[DC_PRED8x8     ]= pred8x8_dc_c;
2918     h->pred8x8[VERT_PRED8x8   ]= pred8x8_vertical_c;
2919     h->pred8x8[HOR_PRED8x8    ]= pred8x8_horizontal_c;
2920     h->pred8x8[PLANE_PRED8x8  ]= pred8x8_plane_c;
2921     h->pred8x8[LEFT_DC_PRED8x8]= pred8x8_left_dc_c;
2922     h->pred8x8[TOP_DC_PRED8x8 ]= pred8x8_top_dc_c;
2923     h->pred8x8[DC_128_PRED8x8 ]= pred8x8_128_dc_c;
2924
2925     h->pred16x16[DC_PRED8x8     ]= pred16x16_dc_c;
2926     h->pred16x16[VERT_PRED8x8   ]= pred16x16_vertical_c;
2927     h->pred16x16[HOR_PRED8x8    ]= pred16x16_horizontal_c;
2928     h->pred16x16[PLANE_PRED8x8  ]= pred16x16_plane_c;
2929     h->pred16x16[LEFT_DC_PRED8x8]= pred16x16_left_dc_c;
2930     h->pred16x16[TOP_DC_PRED8x8 ]= pred16x16_top_dc_c;
2931     h->pred16x16[DC_128_PRED8x8 ]= pred16x16_128_dc_c;
2932 }
2933
2934 static void free_tables(H264Context *h){
2935     av_freep(&h->intra4x4_pred_mode);
2936     av_freep(&h->chroma_pred_mode_table);
2937     av_freep(&h->cbp_table);
2938     av_freep(&h->mvd_table[0]);
2939     av_freep(&h->mvd_table[1]);
2940     av_freep(&h->direct_table);
2941     av_freep(&h->non_zero_count);
2942     av_freep(&h->slice_table_base);
2943     av_freep(&h->top_borders[1]);
2944     av_freep(&h->top_borders[0]);
2945     h->slice_table= NULL;
2946
2947     av_freep(&h->mb2b_xy);
2948     av_freep(&h->mb2b8_xy);
2949
2950     av_freep(&h->s.obmc_scratchpad);
2951 }
2952
2953 static void init_dequant8_coeff_table(H264Context *h){
2954     int i,q,x;
2955     h->dequant8_coeff[0] = h->dequant8_buffer[0];
2956     h->dequant8_coeff[1] = h->dequant8_buffer[1];
2957
2958     for(i=0; i<2; i++ ){
2959         if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
2960             h->dequant8_coeff[1] = h->dequant8_buffer[0];
2961             break;
2962         }
2963
2964         for(q=0; q<52; q++){
2965             int shift = div6[q];
2966             int idx = rem6[q];
2967             for(x=0; x<64; x++)
2968                 h->dequant8_coeff[i][q][x] = ((uint32_t)dequant8_coeff_init[idx][
2969                     dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * h->pps.scaling_matrix8[i][x]) << shift;
2970         }
2971     }
2972 }
2973
2974 static void init_dequant4_coeff_table(H264Context *h){
2975     int i,j,q,x;
2976     const int transpose = (h->s.dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly
2977     for(i=0; i<6; i++ ){
2978         h->dequant4_coeff[i] = h->dequant4_buffer[i];
2979         for(j=0; j<i; j++){
2980             if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
2981                 h->dequant4_coeff[i] = h->dequant4_buffer[j];
2982                 break;
2983             }
2984         }
2985         if(j<i)
2986             continue;
2987
2988         for(q=0; q<52; q++){
2989             int shift = div6[q] + 2;
2990             int idx = rem6[q];
2991             for(x=0; x<16; x++)
2992                 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] =
2993                     ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
2994                     h->pps.scaling_matrix4[i][x]) << shift;
2995         }
2996     }
2997 }
2998
2999 static void init_dequant_tables(H264Context *h){
3000     int i,x;
3001     init_dequant4_coeff_table(h);
3002     if(h->pps.transform_8x8_mode)
3003         init_dequant8_coeff_table(h);
3004     if(h->sps.transform_bypass){
3005         for(i=0; i<6; i++)
3006             for(x=0; x<16; x++)
3007                 h->dequant4_coeff[i][0][x] = 1<<6;
3008         if(h->pps.transform_8x8_mode)
3009             for(i=0; i<2; i++)
3010                 for(x=0; x<64; x++)
3011                     h->dequant8_coeff[i][0][x] = 1<<6;
3012     }
3013 }
3014
3015
3016 /**
3017  * allocates tables.
3018  * needs width/height
3019  */
3020 static int alloc_tables(H264Context *h){
3021     MpegEncContext * const s = &h->s;
3022     const int big_mb_num= s->mb_stride * (s->mb_height+1);
3023     int x,y;
3024
3025     CHECKED_ALLOCZ(h->intra4x4_pred_mode, big_mb_num * 8  * sizeof(uint8_t))
3026
3027     CHECKED_ALLOCZ(h->non_zero_count    , big_mb_num * 16 * sizeof(uint8_t))
3028     CHECKED_ALLOCZ(h->slice_table_base  , big_mb_num * sizeof(uint8_t))
3029     CHECKED_ALLOCZ(h->top_borders[0]    , s->mb_width * (16+8+8) * sizeof(uint8_t))
3030     CHECKED_ALLOCZ(h->top_borders[1]    , s->mb_width * (16+8+8) * sizeof(uint8_t))
3031     CHECKED_ALLOCZ(h->cbp_table, big_mb_num * sizeof(uint16_t))
3032
3033     if( h->pps.cabac ) {
3034         CHECKED_ALLOCZ(h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t))
3035         CHECKED_ALLOCZ(h->mvd_table[0], 32*big_mb_num * sizeof(uint16_t));
3036         CHECKED_ALLOCZ(h->mvd_table[1], 32*big_mb_num * sizeof(uint16_t));
3037         CHECKED_ALLOCZ(h->direct_table, 32*big_mb_num * sizeof(uint8_t));
3038     }
3039
3040     memset(h->slice_table_base, -1, big_mb_num  * sizeof(uint8_t));
3041     h->slice_table= h->slice_table_base + s->mb_stride + 1;
3042
3043     CHECKED_ALLOCZ(h->mb2b_xy  , big_mb_num * sizeof(uint32_t));
3044     CHECKED_ALLOCZ(h->mb2b8_xy , big_mb_num * sizeof(uint32_t));
3045     for(y=0; y<s->mb_height; y++){
3046         for(x=0; x<s->mb_width; x++){
3047             const int mb_xy= x + y*s->mb_stride;
3048             const int b_xy = 4*x + 4*y*h->b_stride;
3049             const int b8_xy= 2*x + 2*y*h->b8_stride;
3050
3051             h->mb2b_xy [mb_xy]= b_xy;
3052             h->mb2b8_xy[mb_xy]= b8_xy;
3053         }
3054     }
3055
3056     s->obmc_scratchpad = NULL;
3057
3058     if(!h->dequant4_coeff[0])
3059         init_dequant_tables(h);
3060
3061     return 0;
3062 fail:
3063     free_tables(h);
3064     return -1;
3065 }
3066
3067 static void common_init(H264Context *h){
3068     MpegEncContext * const s = &h->s;
3069
3070     s->width = s->avctx->width;
3071     s->height = s->avctx->height;
3072     s->codec_id= s->avctx->codec->id;
3073
3074     init_pred_ptrs(h);
3075
3076     h->dequant_coeff_pps= -1;
3077     s->unrestricted_mv=1;
3078     s->decode=1; //FIXME
3079
3080     memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
3081     memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
3082 }
3083
3084 static int decode_init(AVCodecContext *avctx){
3085     H264Context *h= avctx->priv_data;
3086     MpegEncContext * const s = &h->s;
3087
3088     MPV_decode_defaults(s);
3089
3090     s->avctx = avctx;
3091     common_init(h);
3092
3093     s->out_format = FMT_H264;
3094     s->workaround_bugs= avctx->workaround_bugs;
3095
3096     // set defaults
3097 //    s->decode_mb= ff_h263_decode_mb;
3098     s->low_delay= 1;
3099     avctx->pix_fmt= PIX_FMT_YUV420P;
3100
3101     decode_init_vlc(h);
3102
3103     if(avctx->extradata_size > 0 && avctx->extradata &&
3104        *(char *)avctx->extradata == 1){
3105         h->is_avc = 1;
3106         h->got_avcC = 0;
3107     } else {
3108         h->is_avc = 0;
3109     }
3110
3111     return 0;
3112 }
3113
3114 static int frame_start(H264Context *h){
3115     MpegEncContext * const s = &h->s;
3116     int i;
3117
3118     if(MPV_frame_start(s, s->avctx) < 0)
3119         return -1;
3120     ff_er_frame_start(s);
3121
3122     assert(s->linesize && s->uvlinesize);
3123
3124     for(i=0; i<16; i++){
3125         h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
3126         h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
3127     }
3128     for(i=0; i<4; i++){
3129         h->block_offset[16+i]=
3130         h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
3131         h->block_offset[24+16+i]=
3132         h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
3133     }
3134
3135     /* can't be in alloc_tables because linesize isn't known there.
3136      * FIXME: redo bipred weight to not require extra buffer? */
3137     if(!s->obmc_scratchpad)
3138         s->obmc_scratchpad = av_malloc(16*s->linesize + 2*8*s->uvlinesize);
3139
3140 //    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
3141     return 0;
3142 }
3143
3144 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
3145     MpegEncContext * const s = &h->s;
3146     int i;
3147
3148     src_y  -=   linesize;
3149     src_cb -= uvlinesize;
3150     src_cr -= uvlinesize;
3151
3152     // There are two lines saved, the line above the the top macroblock of a pair,
3153     // and the line above the bottom macroblock
3154     h->left_border[0]= h->top_borders[0][s->mb_x][15];
3155     for(i=1; i<17; i++){
3156         h->left_border[i]= src_y[15+i*  linesize];
3157     }
3158
3159     *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y +  16*linesize);
3160     *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+16*linesize);
3161
3162     if(!(s->flags&CODEC_FLAG_GRAY)){
3163         h->left_border[17  ]= h->top_borders[0][s->mb_x][16+7];
3164         h->left_border[17+9]= h->top_borders[0][s->mb_x][24+7];
3165         for(i=1; i<9; i++){
3166             h->left_border[i+17  ]= src_cb[7+i*uvlinesize];
3167             h->left_border[i+17+9]= src_cr[7+i*uvlinesize];
3168         }
3169         *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+8*uvlinesize);
3170         *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+8*uvlinesize);
3171     }
3172 }
3173
3174 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){
3175     MpegEncContext * const s = &h->s;
3176     int temp8, i;
3177     uint64_t temp64;
3178     int deblock_left = (s->mb_x > 0);
3179     int deblock_top  = (s->mb_y > 0);
3180
3181     src_y  -=   linesize + 1;
3182     src_cb -= uvlinesize + 1;
3183     src_cr -= uvlinesize + 1;
3184
3185 #define XCHG(a,b,t,xchg)\
3186 t= a;\
3187 if(xchg)\
3188     a= b;\
3189 b= t;
3190
3191     if(deblock_left){
3192         for(i = !deblock_top; i<17; i++){
3193             XCHG(h->left_border[i     ], src_y [i*  linesize], temp8, xchg);
3194         }
3195     }
3196
3197     if(deblock_top){
3198         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
3199         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
3200         if(s->mb_x+1 < s->mb_width){
3201             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x+1]), *(uint64_t*)(src_y +17), temp64, 1);
3202         }
3203     }
3204
3205     if(!(s->flags&CODEC_FLAG_GRAY)){
3206         if(deblock_left){
3207             for(i = !deblock_top; i<9; i++){
3208                 XCHG(h->left_border[i+17  ], src_cb[i*uvlinesize], temp8, xchg);
3209                 XCHG(h->left_border[i+17+9], src_cr[i*uvlinesize], temp8, xchg);
3210             }
3211         }
3212         if(deblock_top){
3213             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
3214             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
3215         }
3216     }
3217 }
3218
3219 static inline void backup_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize){
3220     MpegEncContext * const s = &h->s;
3221     int i;
3222
3223     src_y  -= 2 *   linesize;
3224     src_cb -= 2 * uvlinesize;
3225     src_cr -= 2 * uvlinesize;
3226
3227     // There are two lines saved, the line above the the top macroblock of a pair,
3228     // and the line above the bottom macroblock
3229     h->left_border[0]= h->top_borders[0][s->mb_x][15];
3230     h->left_border[1]= h->top_borders[1][s->mb_x][15];
3231     for(i=2; i<34; i++){
3232         h->left_border[i]= src_y[15+i*  linesize];
3233     }
3234
3235     *(uint64_t*)(h->top_borders[0][s->mb_x]+0)= *(uint64_t*)(src_y +  32*linesize);
3236     *(uint64_t*)(h->top_borders[0][s->mb_x]+8)= *(uint64_t*)(src_y +8+32*linesize);
3237     *(uint64_t*)(h->top_borders[1][s->mb_x]+0)= *(uint64_t*)(src_y +  33*linesize);
3238     *(uint64_t*)(h->top_borders[1][s->mb_x]+8)= *(uint64_t*)(src_y +8+33*linesize);
3239
3240     if(!(s->flags&CODEC_FLAG_GRAY)){
3241         h->left_border[34     ]= h->top_borders[0][s->mb_x][16+7];
3242         h->left_border[34+   1]= h->top_borders[1][s->mb_x][16+7];
3243         h->left_border[34+18  ]= h->top_borders[0][s->mb_x][24+7];
3244         h->left_border[34+18+1]= h->top_borders[1][s->mb_x][24+7];
3245         for(i=2; i<18; i++){
3246             h->left_border[i+34   ]= src_cb[7+i*uvlinesize];
3247             h->left_border[i+34+18]= src_cr[7+i*uvlinesize];
3248         }
3249         *(uint64_t*)(h->top_borders[0][s->mb_x]+16)= *(uint64_t*)(src_cb+16*uvlinesize);
3250         *(uint64_t*)(h->top_borders[0][s->mb_x]+24)= *(uint64_t*)(src_cr+16*uvlinesize);
3251         *(uint64_t*)(h->top_borders[1][s->mb_x]+16)= *(uint64_t*)(src_cb+17*uvlinesize);
3252         *(uint64_t*)(h->top_borders[1][s->mb_x]+24)= *(uint64_t*)(src_cr+17*uvlinesize);
3253     }
3254 }
3255
3256 static inline void xchg_pair_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg){
3257     MpegEncContext * const s = &h->s;
3258     int temp8, i;
3259     uint64_t temp64;
3260     int deblock_left = (s->mb_x > 0);
3261     int deblock_top  = (s->mb_y > 0);
3262
3263     tprintf("xchg_pair_border: src_y:%p src_cb:%p src_cr:%p ls:%d uvls:%d\n", src_y, src_cb, src_cr, linesize, uvlinesize);
3264
3265     src_y  -= 2 *   linesize + 1;
3266     src_cb -= 2 * uvlinesize + 1;
3267     src_cr -= 2 * uvlinesize + 1;
3268
3269 #define XCHG(a,b,t,xchg)\
3270 t= a;\
3271 if(xchg)\
3272     a= b;\
3273 b= t;
3274
3275     if(deblock_left){
3276         for(i = (!deblock_top)<<1; i<34; i++){
3277             XCHG(h->left_border[i     ], src_y [i*  linesize], temp8, xchg);
3278         }
3279     }
3280
3281     if(deblock_top){
3282         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+0), *(uint64_t*)(src_y +1), temp64, xchg);
3283         XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+8), *(uint64_t*)(src_y +9), temp64, 1);
3284         XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+0), *(uint64_t*)(src_y +1 +linesize), temp64, xchg);
3285         XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+8), *(uint64_t*)(src_y +9 +linesize), temp64, 1);
3286     }
3287
3288     if(!(s->flags&CODEC_FLAG_GRAY)){
3289         if(deblock_left){
3290             for(i = (!deblock_top) << 1; i<18; i++){
3291                 XCHG(h->left_border[i+34   ], src_cb[i*uvlinesize], temp8, xchg);
3292                 XCHG(h->left_border[i+34+18], src_cr[i*uvlinesize], temp8, xchg);
3293             }
3294         }
3295         if(deblock_top){
3296             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+16), *(uint64_t*)(src_cb+1), temp64, 1);
3297             XCHG(*(uint64_t*)(h->top_borders[0][s->mb_x]+24), *(uint64_t*)(src_cr+1), temp64, 1);
3298             XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+16), *(uint64_t*)(src_cb+1 +uvlinesize), temp64, 1);
3299             XCHG(*(uint64_t*)(h->top_borders[1][s->mb_x]+24), *(uint64_t*)(src_cr+1 +uvlinesize), temp64, 1);
3300         }
3301     }
3302 }
3303
3304 static void hl_decode_mb(H264Context *h){
3305     MpegEncContext * const s = &h->s;
3306     const int mb_x= s->mb_x;
3307     const int mb_y= s->mb_y;
3308     const int mb_xy= mb_x + mb_y*s->mb_stride;
3309     const int mb_type= s->current_picture.mb_type[mb_xy];
3310     uint8_t  *dest_y, *dest_cb, *dest_cr;
3311     int linesize, uvlinesize /*dct_offset*/;
3312     int i;
3313     int *block_offset = &h->block_offset[0];
3314     const unsigned int bottom = mb_y & 1;
3315     const int transform_bypass = (s->qscale == 0 && h->sps.transform_bypass);
3316     void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
3317
3318     if(!s->decode)
3319         return;
3320
3321     dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
3322     dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3323     dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3324
3325     if (h->mb_field_decoding_flag) {
3326         linesize = s->linesize * 2;
3327         uvlinesize = s->uvlinesize * 2;
3328         block_offset = &h->block_offset[24];
3329         if(mb_y&1){ //FIXME move out of this func?
3330             dest_y -= s->linesize*15;
3331             dest_cb-= s->uvlinesize*7;
3332             dest_cr-= s->uvlinesize*7;
3333         }
3334     } else {
3335         linesize = s->linesize;
3336         uvlinesize = s->uvlinesize;
3337 //        dct_offset = s->linesize * 16;
3338     }
3339
3340     idct_add = transform_bypass
3341              ? IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4
3342              : IS_8x8DCT(mb_type) ? s->dsp.h264_idct8_add : s->dsp.h264_idct_add;
3343
3344     if (IS_INTRA_PCM(mb_type)) {
3345         unsigned int x, y;
3346
3347         // The pixels are stored in h->mb array in the same order as levels,
3348         // copy them in output in the correct order.
3349         for(i=0; i<16; i++) {
3350             for (y=0; y<4; y++) {
3351                 for (x=0; x<4; x++) {
3352                     *(dest_y + block_offset[i] + y*linesize + x) = h->mb[i*16+y*4+x];
3353                 }
3354             }
3355         }
3356         for(i=16; i<16+4; i++) {
3357             for (y=0; y<4; y++) {
3358                 for (x=0; x<4; x++) {
3359                     *(dest_cb + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
3360                 }
3361             }
3362         }
3363         for(i=20; i<20+4; i++) {
3364             for (y=0; y<4; y++) {
3365                 for (x=0; x<4; x++) {
3366                     *(dest_cr + block_offset[i] + y*uvlinesize + x) = h->mb[i*16+y*4+x];
3367                 }
3368             }
3369         }
3370     } else {
3371         if(IS_INTRA(mb_type)){
3372             if(h->deblocking_filter) {
3373                 if (h->mb_aff_frame) {
3374                     if (!bottom)
3375                         xchg_pair_border(h, dest_y, dest_cb, dest_cr, s->linesize, s->uvlinesize, 1);
3376                 } else {
3377                     xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1);
3378                 }
3379             }
3380
3381             if(!(s->flags&CODEC_FLAG_GRAY)){
3382                 h->pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
3383                 h->pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
3384             }
3385
3386             if(IS_INTRA4x4(mb_type)){
3387                 if(!s->encoding){
3388                     if(IS_8x8DCT(mb_type)){
3389                         for(i=0; i<16; i+=4){
3390                             uint8_t * const ptr= dest_y + block_offset[i];
3391                             const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
3392                             h->pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
3393                                                    (h->topright_samples_available<<(i+1))&0x8000, linesize);
3394                             if(h->non_zero_count_cache[ scan8[i] ])
3395                                 idct_add(ptr, h->mb + i*16, linesize);
3396                         }
3397                     }else
3398                     for(i=0; i<16; i++){
3399                         uint8_t * const ptr= dest_y + block_offset[i];
3400                         uint8_t *topright;
3401                         const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
3402                         int tr;
3403
3404                         if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
3405                             const int topright_avail= (h->topright_samples_available<<i)&0x8000;
3406                             assert(mb_y || linesize <= block_offset[i]);
3407                             if(!topright_avail){
3408                                 tr= ptr[3 - linesize]*0x01010101;
3409                                 topright= (uint8_t*) &tr;
3410                             }else
3411                                 topright= ptr + 4 - linesize;
3412                         }else
3413                             topright= NULL;
3414
3415                         h->pred4x4[ dir ](ptr, topright, linesize);
3416                         if(h->non_zero_count_cache[ scan8[i] ]){
3417                             if(s->codec_id == CODEC_ID_H264)
3418                                 idct_add(ptr, h->mb + i*16, linesize);
3419                             else
3420                                 svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
3421                         }
3422                     }
3423                 }
3424             }else{
3425                 h->pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
3426                 if(s->codec_id == CODEC_ID_H264){
3427                     if(!transform_bypass)
3428                         h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[IS_INTRA(mb_type) ? 0:3][s->qscale][0]);
3429                 }else
3430                     svq3_luma_dc_dequant_idct_c(h->mb, s->qscale);
3431             }
3432             if(h->deblocking_filter) {
3433                 if (h->mb_aff_frame) {
3434                     if (bottom) {
3435                         uint8_t *pair_dest_y  = s->current_picture.data[0] + ((mb_y-1) * 16* s->linesize  ) + mb_x * 16;
3436                         uint8_t *pair_dest_cb = s->current_picture.data[1] + ((mb_y-1) * 8 * s->uvlinesize) + mb_x * 8;
3437                         uint8_t *pair_dest_cr = s->current_picture.data[2] + ((mb_y-1) * 8 * s->uvlinesize) + mb_x * 8;
3438                         s->mb_y--;
3439                         xchg_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize, 0);
3440                         s->mb_y++;
3441                     }
3442                 } else {
3443                     xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
3444                 }
3445             }
3446         }else if(s->codec_id == CODEC_ID_H264){
3447             hl_motion(h, dest_y, dest_cb, dest_cr,
3448                       s->dsp.put_h264_qpel_pixels_tab, s->dsp.put_h264_chroma_pixels_tab,
3449                       s->dsp.avg_h264_qpel_pixels_tab, s->dsp.avg_h264_chroma_pixels_tab,
3450                       s->dsp.weight_h264_pixels_tab, s->dsp.biweight_h264_pixels_tab);
3451         }
3452
3453
3454         if(!IS_INTRA4x4(mb_type)){
3455             if(s->codec_id == CODEC_ID_H264){
3456                 const int di = IS_8x8DCT(mb_type) ? 4 : 1;
3457                 for(i=0; i<16; i+=di){
3458                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
3459                         uint8_t * const ptr= dest_y + block_offset[i];
3460                         idct_add(ptr, h->mb + i*16, linesize);
3461                     }
3462                 }
3463             }else{
3464                 for(i=0; i<16; i++){
3465                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
3466                         uint8_t * const ptr= dest_y + block_offset[i];
3467                         svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
3468                     }
3469                 }
3470             }
3471         }
3472
3473         if(!(s->flags&CODEC_FLAG_GRAY)){
3474             idct_add = transform_bypass ? s->dsp.add_pixels4 : s->dsp.h264_idct_add;
3475             if(!transform_bypass){
3476                 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp][0]);
3477                 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp][0]);
3478             }
3479             if(s->codec_id == CODEC_ID_H264){
3480                 for(i=16; i<16+4; i++){
3481                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
3482                         uint8_t * const ptr= dest_cb + block_offset[i];
3483                         idct_add(ptr, h->mb + i*16, uvlinesize);
3484                     }
3485                 }
3486                 for(i=20; i<20+4; i++){
3487                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
3488                         uint8_t * const ptr= dest_cr + block_offset[i];
3489                         idct_add(ptr, h->mb + i*16, uvlinesize);
3490                     }
3491                 }
3492             }else{
3493                 for(i=16; i<16+4; i++){
3494                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
3495                         uint8_t * const ptr= dest_cb + block_offset[i];
3496                         svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
3497                     }
3498                 }
3499                 for(i=20; i<20+4; i++){
3500                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
3501                         uint8_t * const ptr= dest_cr + block_offset[i];
3502                         svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, chroma_qp[s->qscale + 12] - 12, 2);
3503                     }
3504                 }
3505             }
3506         }
3507     }
3508     if(h->deblocking_filter) {
3509         if (h->mb_aff_frame) {
3510             const int mb_y = s->mb_y - 1;
3511             uint8_t  *pair_dest_y, *pair_dest_cb, *pair_dest_cr;
3512             const int mb_xy= mb_x + mb_y*s->mb_stride;
3513             const int mb_type_top   = s->current_picture.mb_type[mb_xy];
3514             const int mb_type_bottom= s->current_picture.mb_type[mb_xy+s->mb_stride];
3515             uint8_t tmp = s->current_picture.data[1][384];
3516             if (!bottom) return;
3517             pair_dest_y  = s->current_picture.data[0] + (mb_y * 16* s->linesize  ) + mb_x * 16;
3518             pair_dest_cb = s->current_picture.data[1] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3519             pair_dest_cr = s->current_picture.data[2] + (mb_y * 8 * s->uvlinesize) + mb_x * 8;
3520
3521             backup_pair_border(h, pair_dest_y, pair_dest_cb, pair_dest_cr, s->linesize, s->uvlinesize);
3522             // TODO deblock a pair
3523             // top
3524             s->mb_y--;
3525             tprintf("call mbaff filter_mb mb_x:%d mb_y:%d pair_dest_y = %p, dest_y = %p\n", mb_x, mb_y, pair_dest_y, dest_y);
3526             fill_caches(h, mb_type_top, 1); //FIXME don't fill stuff which isn't used by filter_mb
3527             filter_mb(h, mb_x, mb_y, pair_dest_y, pair_dest_cb, pair_dest_cr, linesize, uvlinesize);
3528             if (tmp != s->current_picture.data[1][384]) {
3529                 tprintf("modified pixel 8,1 (1)\n");
3530             }
3531             // bottom
3532             s->mb_y++;
3533             tprintf("call mbaff filter_mb\n");
3534             fill_caches(h, mb_type_bottom, 1); //FIXME don't fill stuff which isn't used by filter_mb
3535             filter_mb(h, mb_x, mb_y+1, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3536             if (tmp != s->current_picture.data[1][384]) {
3537                 tprintf("modified pixel 8,1 (2)\n");
3538             }
3539         } else {
3540             tprintf("call filter_mb\n");
3541             backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3542             fill_caches(h, mb_type, 1); //FIXME don't fill stuff which isn't used by filter_mb
3543             filter_mb(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
3544         }
3545     }
3546 }
3547
3548 /**
3549  * fills the default_ref_list.
3550  */
3551 static int fill_default_ref_list(H264Context *h){
3552     MpegEncContext * const s = &h->s;
3553     int i;
3554     int smallest_poc_greater_than_current = -1;
3555     Picture sorted_short_ref[32];
3556
3557     if(h->slice_type==B_TYPE){
3558         int out_i;
3559         int limit= INT_MIN;
3560
3561         /* sort frame according to poc in B slice */
3562         for(out_i=0; out_i<h->short_ref_count; out_i++){
3563             int best_i=INT_MIN;
3564             int best_poc=INT_MAX;
3565
3566             for(i=0; i<h->short_ref_count; i++){
3567                 const int poc= h->short_ref[i]->poc;
3568                 if(poc > limit && poc < best_poc){
3569                     best_poc= poc;
3570                     best_i= i;
3571                 }
3572             }
3573
3574             assert(best_i != INT_MIN);
3575
3576             limit= best_poc;
3577             sorted_short_ref[out_i]= *h->short_ref[best_i];
3578             tprintf("sorted poc: %d->%d poc:%d fn:%d\n", best_i, out_i, sorted_short_ref[out_i].poc, sorted_short_ref[out_i].frame_num);
3579             if (-1 == smallest_poc_greater_than_current) {
3580                 if (h->short_ref[best_i]->poc >= s->current_picture_ptr->poc) {
3581                     smallest_poc_greater_than_current = out_i;
3582                 }
3583             }
3584         }
3585     }
3586
3587     if(s->picture_structure == PICT_FRAME){
3588         if(h->slice_type==B_TYPE){
3589             int list;
3590             tprintf("current poc: %d, smallest_poc_greater_than_current: %d\n", s->current_picture_ptr->poc, smallest_poc_greater_than_current);
3591
3592             // find the largest poc
3593             for(list=0; list<2; list++){
3594                 int index = 0;
3595                 int j= -99;
3596                 int step= list ? -1 : 1;
3597
3598                 for(i=0; i<h->short_ref_count && index < h->ref_count[list]; i++, j+=step) {
3599                     while(j<0 || j>= h->short_ref_count){
3600                         if(j != -99 && step == (list ? -1 : 1))
3601                             return -1;
3602                         step = -step;
3603                         j= smallest_poc_greater_than_current + (step>>1);
3604                     }
3605                     if(sorted_short_ref[j].reference != 3) continue;
3606                     h->default_ref_list[list][index  ]= sorted_short_ref[j];
3607                     h->default_ref_list[list][index++].pic_id= sorted_short_ref[j].frame_num;
3608                 }
3609
3610                 for(i = 0; i < 16 && index < h->ref_count[ list ]; i++){
3611                     if(h->long_ref[i] == NULL) continue;
3612                     if(h->long_ref[i]->reference != 3) continue;
3613
3614                     h->default_ref_list[ list ][index  ]= *h->long_ref[i];
3615                     h->default_ref_list[ list ][index++].pic_id= i;;
3616                 }
3617
3618                 if(list && (smallest_poc_greater_than_current<=0 || smallest_poc_greater_than_current>=h->short_ref_count) && (1 < index)){
3619                     // swap the two first elements of L1 when
3620                     // L0 and L1 are identical
3621                     Picture temp= h->default_ref_list[1][0];
3622                     h->default_ref_list[1][0] = h->default_ref_list[1][1];
3623                     h->default_ref_list[1][1] = temp;
3624                 }
3625
3626                 if(index < h->ref_count[ list ])
3627                     memset(&h->default_ref_list[list][index], 0, sizeof(Picture)*(h->ref_count[ list ] - index));
3628             }
3629         }else{
3630             int index=0;
3631             for(i=0; i<h->short_ref_count; i++){
3632                 if(h->short_ref[i]->reference != 3) continue; //FIXME refernce field shit
3633                 h->default_ref_list[0][index  ]= *h->short_ref[i];
3634                 h->default_ref_list[0][index++].pic_id= h->short_ref[i]->frame_num;
3635             }
3636             for(i = 0; i < 16; i++){
3637                 if(h->long_ref[i] == NULL) continue;
3638                 if(h->long_ref[i]->reference != 3) continue;
3639                 h->default_ref_list[0][index  ]= *h->long_ref[i];
3640                 h->default_ref_list[0][index++].pic_id= i;;
3641             }
3642             if(index < h->ref_count[0])
3643                 memset(&h->default_ref_list[0][index], 0, sizeof(Picture)*(h->ref_count[0] - index));
3644         }
3645     }else{ //FIELD
3646         if(h->slice_type==B_TYPE){
3647         }else{
3648             //FIXME second field balh
3649         }
3650     }
3651 #ifdef TRACE
3652     for (i=0; i<h->ref_count[0]; i++) {
3653         tprintf("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]);
3654     }
3655     if(h->slice_type==B_TYPE){
3656         for (i=0; i<h->ref_count[1]; i++) {
3657             tprintf("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[0][i].data[0]);
3658         }
3659     }
3660 #endif
3661     return 0;
3662 }
3663
3664 static void print_short_term(H264Context *h);
3665 static void print_long_term(H264Context *h);
3666
3667 static int decode_ref_pic_list_reordering(H264Context *h){
3668     MpegEncContext * const s = &h->s;
3669     int list, index;
3670
3671     print_short_term(h);
3672     print_long_term(h);
3673     if(h->slice_type==I_TYPE || h->slice_type==SI_TYPE) return 0; //FIXME move before func
3674
3675     for(list=0; list<2; list++){
3676         memcpy(h->ref_list[list], h->default_ref_list[list], sizeof(Picture)*h->ref_count[list]);
3677
3678         if(get_bits1(&s->gb)){
3679             int pred= h->curr_pic_num;
3680
3681             for(index=0; ; index++){
3682                 int reordering_of_pic_nums_idc= get_ue_golomb(&s->gb);
3683                 int pic_id;
3684                 int i;
3685                 Picture *ref = NULL;
3686
3687                 if(reordering_of_pic_nums_idc==3)
3688                     break;
3689
3690                 if(index >= h->ref_count[list]){
3691                     av_log(h->s.avctx, AV_LOG_ERROR, "reference count overflow\n");
3692                     return -1;
3693                 }
3694
3695                 if(reordering_of_pic_nums_idc<3){
3696                     if(reordering_of_pic_nums_idc<2){
3697                         const int abs_diff_pic_num= get_ue_golomb(&s->gb) + 1;
3698
3699                         if(abs_diff_pic_num >= h->max_pic_num){
3700                             av_log(h->s.avctx, AV_LOG_ERROR, "abs_diff_pic_num overflow\n");
3701                             return -1;
3702                         }
3703
3704                         if(reordering_of_pic_nums_idc == 0) pred-= abs_diff_pic_num;
3705                         else                                pred+= abs_diff_pic_num;
3706                         pred &= h->max_pic_num - 1;
3707
3708                         for(i= h->short_ref_count-1; i>=0; i--){
3709                             ref = h->short_ref[i];
3710                             assert(ref->reference == 3);
3711                             assert(!ref->long_ref);
3712                             if(ref->data[0] != NULL && ref->frame_num == pred && ref->long_ref == 0) // ignore non existing pictures by testing data[0] pointer
3713                                 break;
3714                         }
3715                         if(i>=0)
3716                             ref->pic_id= ref->frame_num;
3717                     }else{
3718                         pic_id= get_ue_golomb(&s->gb); //long_term_pic_idx
3719                         ref = h->long_ref[pic_id];
3720                         ref->pic_id= pic_id;
3721                         assert(ref->reference == 3);
3722                         assert(ref->long_ref);
3723                         i=0;
3724                     }
3725
3726                     if (i < 0) {
3727                         av_log(h->s.avctx, AV_LOG_ERROR, "reference picture missing during reorder\n");
3728                         memset(&h->ref_list[list][index], 0, sizeof(Picture)); //FIXME
3729                     } else {
3730                         for(i=index; i+1<h->ref_count[list]; i++){
3731                             if(ref->long_ref == h->ref_list[list][i].long_ref && ref->pic_id == h->ref_list[list][i].pic_id)
3732                                 break;
3733                         }
3734                         for(; i > index; i--){
3735                             h->ref_list[list][i]= h->ref_list[list][i-1];
3736                         }
3737                         h->ref_list[list][index]= *ref;
3738                     }
3739                 }else{
3740                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal reordering_of_pic_nums_idc\n");
3741                     return -1;
3742                 }
3743             }
3744         }
3745
3746         if(h->slice_type!=B_TYPE) break;
3747     }
3748     for(list=0; list<2; list++){
3749         for(index= 0; index < h->ref_count[list]; index++){
3750             if(!h->ref_list[list][index].data[0])
3751                 h->ref_list[list][index]= s->current_picture;
3752         }
3753         if(h->slice_type!=B_TYPE) break;
3754     }
3755
3756     if(h->slice_type==B_TYPE && !h->direct_spatial_mv_pred)
3757         direct_dist_scale_factor(h);
3758     direct_ref_list_init(h);
3759     return 0;
3760 }
3761
3762 static int pred_weight_table(H264Context *h){
3763     MpegEncContext * const s = &h->s;
3764     int list, i;
3765     int luma_def, chroma_def;
3766
3767     h->use_weight= 0;
3768     h->use_weight_chroma= 0;
3769     h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
3770     h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
3771     luma_def = 1<<h->luma_log2_weight_denom;
3772     chroma_def = 1<<h->chroma_log2_weight_denom;
3773
3774     for(list=0; list<2; list++){
3775         for(i=0; i<h->ref_count[list]; i++){
3776             int luma_weight_flag, chroma_weight_flag;
3777
3778             luma_weight_flag= get_bits1(&s->gb);
3779             if(luma_weight_flag){
3780                 h->luma_weight[list][i]= get_se_golomb(&s->gb);
3781                 h->luma_offset[list][i]= get_se_golomb(&s->gb);
3782                 if(   h->luma_weight[list][i] != luma_def
3783                    || h->luma_offset[list][i] != 0)
3784                     h->use_weight= 1;
3785             }else{
3786                 h->luma_weight[list][i]= luma_def;
3787                 h->luma_offset[list][i]= 0;
3788             }
3789
3790             chroma_weight_flag= get_bits1(&s->gb);
3791             if(chroma_weight_flag){
3792                 int j;
3793                 for(j=0; j<2; j++){
3794                     h->chroma_weight[list][i][j]= get_se_golomb(&s->gb);
3795                     h->chroma_offset[list][i][j]= get_se_golomb(&s->gb);
3796                     if(   h->chroma_weight[list][i][j] != chroma_def
3797                        || h->chroma_offset[list][i][j] != 0)
3798                         h->use_weight_chroma= 1;
3799                 }
3800             }else{
3801                 int j;
3802                 for(j=0; j<2; j++){
3803                     h->chroma_weight[list][i][j]= chroma_def;
3804                     h->chroma_offset[list][i][j]= 0;
3805                 }
3806             }
3807         }
3808         if(h->slice_type != B_TYPE) break;
3809     }
3810     h->use_weight= h->use_weight || h->use_weight_chroma;
3811     return 0;
3812 }
3813
3814 static void implicit_weight_table(H264Context *h){
3815     MpegEncContext * const s = &h->s;
3816     int ref0, ref1;
3817     int cur_poc = s->current_picture_ptr->poc;
3818
3819     if(   h->ref_count[0] == 1 && h->ref_count[1] == 1
3820        && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
3821         h->use_weight= 0;
3822         h->use_weight_chroma= 0;
3823         return;
3824     }
3825
3826     h->use_weight= 2;
3827     h->use_weight_chroma= 2;
3828     h->luma_log2_weight_denom= 5;
3829     h->chroma_log2_weight_denom= 5;
3830
3831     /* FIXME: MBAFF */
3832     for(ref0=0; ref0 < h->ref_count[0]; ref0++){
3833         int poc0 = h->ref_list[0][ref0].poc;
3834         for(ref1=0; ref1 < h->ref_count[1]; ref1++){
3835             int poc1 = h->ref_list[1][ref1].poc;
3836             int td = clip(poc1 - poc0, -128, 127);
3837             if(td){
3838                 int tb = clip(cur_poc - poc0, -128, 127);
3839                 int tx = (16384 + (ABS(td) >> 1)) / td;
3840                 int dist_scale_factor = clip((tb*tx + 32) >> 6, -1024, 1023) >> 2;
3841                 if(dist_scale_factor < -64 || dist_scale_factor > 128)
3842                     h->implicit_weight[ref0][ref1] = 32;
3843                 else
3844                     h->implicit_weight[ref0][ref1] = 64 - dist_scale_factor;
3845             }else
3846                 h->implicit_weight[ref0][ref1] = 32;
3847         }
3848     }
3849 }
3850
3851 static inline void unreference_pic(H264Context *h, Picture *pic){
3852     int i;
3853     pic->reference=0;
3854     if(pic == h->delayed_output_pic)
3855         pic->reference=1;
3856     else{
3857         for(i = 0; h->delayed_pic[i]; i++)
3858             if(pic == h->delayed_pic[i]){
3859                 pic->reference=1;
3860                 break;
3861             }
3862     }
3863 }
3864
3865 /**
3866  * instantaneous decoder refresh.
3867  */
3868 static void idr(H264Context *h){
3869     int i;
3870
3871     for(i=0; i<16; i++){
3872         if (h->long_ref[i] != NULL) {
3873             unreference_pic(h, h->long_ref[i]);
3874             h->long_ref[i]= NULL;
3875         }
3876     }
3877     h->long_ref_count=0;
3878
3879     for(i=0; i<h->short_ref_count; i++){
3880         unreference_pic(h, h->short_ref[i]);
3881         h->short_ref[i]= NULL;
3882     }
3883     h->short_ref_count=0;
3884 }
3885
3886 /* forget old pics after a seek */
3887 static void flush_dpb(AVCodecContext *avctx){
3888     H264Context *h= avctx->priv_data;
3889     int i;
3890     for(i=0; i<16; i++)
3891         h->delayed_pic[i]= NULL;
3892     h->delayed_output_pic= NULL;
3893     idr(h);
3894     if(h->s.current_picture_ptr)
3895         h->s.current_picture_ptr->reference= 0;
3896 }
3897
3898 /**
3899  *
3900  * @return the removed picture or NULL if an error occurs
3901  */
3902 static Picture * remove_short(H264Context *h, int frame_num){
3903     MpegEncContext * const s = &h->s;
3904     int i;
3905
3906     if(s->avctx->debug&FF_DEBUG_MMCO)
3907         av_log(h->s.avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
3908
3909     for(i=0; i<h->short_ref_count; i++){
3910         Picture *pic= h->short_ref[i];
3911         if(s->avctx->debug&FF_DEBUG_MMCO)
3912             av_log(h->s.avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
3913         if(pic->frame_num == frame_num){
3914             h->short_ref[i]= NULL;
3915             memmove(&h->short_ref[i], &h->short_ref[i+1], (h->short_ref_count - i - 1)*sizeof(Picture*));
3916             h->short_ref_count--;
3917             return pic;
3918         }
3919     }
3920     return NULL;
3921 }
3922
3923 /**
3924  *
3925  * @return the removed picture or NULL if an error occurs
3926  */
3927 static Picture * remove_long(H264Context *h, int i){
3928     Picture *pic;
3929
3930     pic= h->long_ref[i];
3931     h->long_ref[i]= NULL;
3932     if(pic) h->long_ref_count--;
3933
3934     return pic;
3935 }
3936
3937 /**
3938  * print short term list
3939  */
3940 static void print_short_term(H264Context *h) {
3941     uint32_t i;
3942     if(h->s.avctx->debug&FF_DEBUG_MMCO) {
3943         av_log(h->s.avctx, AV_LOG_DEBUG, "short term list:\n");
3944         for(i=0; i<h->short_ref_count; i++){
3945             Picture *pic= h->short_ref[i];
3946             av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
3947         }
3948     }
3949 }
3950
3951 /**
3952  * print long term list
3953  */
3954 static void print_long_term(H264Context *h) {
3955     uint32_t i;
3956     if(h->s.avctx->debug&FF_DEBUG_MMCO) {
3957         av_log(h->s.avctx, AV_LOG_DEBUG, "long term list:\n");
3958         for(i = 0; i < 16; i++){
3959             Picture *pic= h->long_ref[i];
3960             if (pic) {
3961                 av_log(h->s.avctx, AV_LOG_DEBUG, "%d fn:%d poc:%d %p\n", i, pic->frame_num, pic->poc, pic->data[0]);
3962             }
3963         }
3964     }
3965 }
3966
3967 /**
3968  * Executes the reference picture marking (memory management control operations).
3969  */
3970 static int execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count){
3971     MpegEncContext * const s = &h->s;
3972     int i, j;
3973     int current_is_long=0;
3974     Picture *pic;
3975
3976     if((s->avctx->debug&FF_DEBUG_MMCO) && mmco_count==0)
3977         av_log(h->s.avctx, AV_LOG_DEBUG, "no mmco here\n");
3978
3979     for(i=0; i<mmco_count; i++){
3980         if(s->avctx->debug&FF_DEBUG_MMCO)
3981             av_log(h->s.avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, h->mmco[i].short_frame_num, h->mmco[i].long_index);
3982
3983         switch(mmco[i].opcode){
3984         case MMCO_SHORT2UNUSED:
3985             pic= remove_short(h, mmco[i].short_frame_num);
3986             if(pic)
3987                 unreference_pic(h, pic);
3988             else if(s->avctx->debug&FF_DEBUG_MMCO)
3989                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_short() failure\n");
3990             break;
3991         case MMCO_SHORT2LONG:
3992             pic= remove_long(h, mmco[i].long_index);
3993             if(pic) unreference_pic(h, pic);
3994
3995             h->long_ref[ mmco[i].long_index ]= remove_short(h, mmco[i].short_frame_num);
3996             h->long_ref[ mmco[i].long_index ]->long_ref=1;
3997             h->long_ref_count++;
3998             break;
3999         case MMCO_LONG2UNUSED:
4000             pic= remove_long(h, mmco[i].long_index);
4001             if(pic)
4002                 unreference_pic(h, pic);
4003             else if(s->avctx->debug&FF_DEBUG_MMCO)
4004                 av_log(h->s.avctx, AV_LOG_DEBUG, "mmco: remove_long() failure\n");
4005             break;
4006         case MMCO_LONG:
4007             pic= remove_long(h, mmco[i].long_index);
4008             if(pic) unreference_pic(h, pic);
4009
4010             h->long_ref[ mmco[i].long_index ]= s->current_picture_ptr;
4011             h->long_ref[ mmco[i].long_index ]->long_ref=1;
4012             h->long_ref_count++;
4013
4014             current_is_long=1;
4015             break;
4016         case MMCO_SET_MAX_LONG:
4017             assert(mmco[i].long_index <= 16);
4018             // just remove the long term which index is greater than new max
4019             for(j = mmco[i].long_index; j<16; j++){
4020                 pic = remove_long(h, j);
4021                 if (pic) unreference_pic(h, pic);
4022             }
4023             break;
4024         case MMCO_RESET:
4025             while(h->short_ref_count){
4026                 pic= remove_short(h, h->short_ref[0]->frame_num);
4027                 unreference_pic(h, pic);
4028             }
4029             for(j = 0; j < 16; j++) {
4030                 pic= remove_long(h, j);
4031                 if(pic) unreference_pic(h, pic);
4032             }
4033             break;
4034         default: assert(0);
4035         }
4036     }
4037
4038     if(!current_is_long){
4039         pic= remove_short(h, s->current_picture_ptr->frame_num);
4040         if(pic){
4041             unreference_pic(h, pic);
4042             av_log(h->s.avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
4043         }
4044
4045         if(h->short_ref_count)
4046             memmove(&h->short_ref[1], &h->short_ref[0], h->short_ref_count*sizeof(Picture*));
4047
4048         h->short_ref[0]= s->current_picture_ptr;
4049         h->short_ref[0]->long_ref=0;
4050         h->short_ref_count++;
4051     }
4052
4053     print_short_term(h);
4054     print_long_term(h);
4055     return 0;
4056 }
4057
4058 static int decode_ref_pic_marking(H264Context *h){
4059     MpegEncContext * const s = &h->s;
4060     int i;
4061
4062     if(h->nal_unit_type == NAL_IDR_SLICE){ //FIXME fields
4063         s->broken_link= get_bits1(&s->gb) -1;
4064         h->mmco[0].long_index= get_bits1(&s->gb) - 1; // current_long_term_idx
4065         if(h->mmco[0].long_index == -1)
4066             h->mmco_index= 0;
4067         else{
4068             h->mmco[0].opcode= MMCO_LONG;
4069             h->mmco_index= 1;
4070         }
4071     }else{
4072         if(get_bits1(&s->gb)){ // adaptive_ref_pic_marking_mode_flag
4073             for(i= 0; i<MAX_MMCO_COUNT; i++) {
4074                 MMCOOpcode opcode= get_ue_golomb(&s->gb);;
4075
4076                 h->mmco[i].opcode= opcode;
4077                 if(opcode==MMCO_SHORT2UNUSED || opcode==MMCO_SHORT2LONG){
4078                     h->mmco[i].short_frame_num= (h->frame_num - get_ue_golomb(&s->gb) - 1) & ((1<<h->sps.log2_max_frame_num)-1); //FIXME fields
4079 /*                    if(h->mmco[i].short_frame_num >= h->short_ref_count || h->short_ref[ h->mmco[i].short_frame_num ] == NULL){
4080                         av_log(s->avctx, AV_LOG_ERROR, "illegal short ref in memory management control operation %d\n", mmco);
4081                         return -1;
4082                     }*/
4083                 }
4084                 if(opcode==MMCO_SHORT2LONG || opcode==MMCO_LONG2UNUSED || opcode==MMCO_LONG || opcode==MMCO_SET_MAX_LONG){
4085                     h->mmco[i].long_index= get_ue_golomb(&s->gb);
4086                     if(/*h->mmco[i].long_index >= h->long_ref_count || h->long_ref[ h->mmco[i].long_index ] == NULL*/ h->mmco[i].long_index >= 16){
4087                         av_log(h->s.avctx, AV_LOG_ERROR, "illegal long ref in memory management control operation %d\n", opcode);
4088                         return -1;
4089                     }
4090                 }
4091
4092                 if(opcode > MMCO_LONG){
4093                     av_log(h->s.avctx, AV_LOG_ERROR, "illegal memory management control operation %d\n", opcode);
4094                     return -1;
4095                 }
4096                 if(opcode == MMCO_END)
4097                     break;
4098             }
4099             h->mmco_index= i;
4100         }else{
4101             assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
4102
4103             if(h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count){ //FIXME fields
4104                 h->mmco[0].opcode= MMCO_SHORT2UNUSED;
4105                 h->mmco[0].short_frame_num= h->short_ref[ h->short_ref_count - 1 ]->frame_num;
4106                 h->mmco_index= 1;
4107             }else
4108                 h->mmco_index= 0;
4109         }
4110     }
4111
4112     return 0;
4113 }
4114
4115 static int init_poc(H264Context *h){
4116     MpegEncContext * const s = &h->s;
4117     const int max_frame_num= 1<<h->sps.log2_max_frame_num;
4118     int field_poc[2];
4119
4120     if(h->nal_unit_type == NAL_IDR_SLICE){
4121         h->frame_num_offset= 0;
4122     }else{
4123         if(h->frame_num < h->prev_frame_num)
4124             h->frame_num_offset= h->prev_frame_num_offset + max_frame_num;
4125         else
4126             h->frame_num_offset= h->prev_frame_num_offset;
4127     }
4128
4129     if(h->sps.poc_type==0){
4130         const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
4131
4132         if(h->nal_unit_type == NAL_IDR_SLICE){
4133              h->prev_poc_msb=
4134              h->prev_poc_lsb= 0;
4135         }
4136
4137         if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
4138             h->poc_msb = h->prev_poc_msb + max_poc_lsb;
4139         else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
4140             h->poc_msb = h->prev_poc_msb - max_poc_lsb;
4141         else
4142             h->poc_msb = h->prev_poc_msb;
4143 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
4144         field_poc[0] =
4145         field_poc[1] = h->poc_msb + h->poc_lsb;
4146         if(s->picture_structure == PICT_FRAME)
4147             field_poc[1] += h->delta_poc_bottom;
4148     }else if(h->sps.poc_type==1){
4149         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
4150         int i;
4151
4152         if(h->sps.poc_cycle_length != 0)
4153             abs_frame_num = h->frame_num_offset + h->frame_num;
4154         else
4155             abs_frame_num = 0;
4156
4157         if(h->nal_ref_idc==0 && abs_frame_num > 0)
4158             abs_frame_num--;
4159
4160         expected_delta_per_poc_cycle = 0;
4161         for(i=0; i < h->sps.poc_cycle_length; i++)
4162             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
4163
4164         if(abs_frame_num > 0){
4165             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
4166             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
4167
4168             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
4169             for(i = 0; i <= frame_num_in_poc_cycle; i++)
4170                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
4171         } else
4172             expectedpoc = 0;
4173
4174         if(h->nal_ref_idc == 0)
4175             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
4176
4177         field_poc[0] = expectedpoc + h->delta_poc[0];
4178         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
4179
4180         if(s->picture_structure == PICT_FRAME)
4181             field_poc[1] += h->delta_poc[1];
4182     }else{
4183         int poc;
4184         if(h->nal_unit_type == NAL_IDR_SLICE){
4185             poc= 0;
4186         }else{
4187             if(h->nal_ref_idc) poc= 2*(h->frame_num_offset + h->frame_num);
4188             else               poc= 2*(h->frame_num_offset + h->frame_num) - 1;
4189         }
4190         field_poc[0]= poc;
4191         field_poc[1]= poc;
4192     }
4193
4194     if(s->picture_structure != PICT_BOTTOM_FIELD)
4195         s->current_picture_ptr->field_poc[0]= field_poc[0];
4196     if(s->picture_structure != PICT_TOP_FIELD)
4197         s->current_picture_ptr->field_poc[1]= field_poc[1];
4198     if(s->picture_structure == PICT_FRAME) // FIXME field pix?
4199         s->current_picture_ptr->poc= FFMIN(field_poc[0], field_poc[1]);
4200
4201     return 0;
4202 }
4203
4204 /**
4205  * decodes a slice header.
4206  * this will allso call MPV_common_init() and frame_start() as needed
4207  */
4208 static int decode_slice_header(H264Context *h){
4209     MpegEncContext * const s = &h->s;
4210     int first_mb_in_slice, pps_id;
4211     int num_ref_idx_active_override_flag;
4212     static const uint8_t slice_type_map[5]= {P_TYPE, B_TYPE, I_TYPE, SP_TYPE, SI_TYPE};
4213     int slice_type;
4214     int default_ref_list_done = 0;
4215
4216     s->current_picture.reference= h->nal_ref_idc != 0;
4217     s->dropable= h->nal_ref_idc == 0;
4218
4219     first_mb_in_slice= get_ue_golomb(&s->gb);
4220
4221     slice_type= get_ue_golomb(&s->gb);
4222     if(slice_type > 9){
4223         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);
4224         return -1;
4225     }
4226     if(slice_type > 4){
4227         slice_type -= 5;
4228         h->slice_type_fixed=1;
4229     }else
4230         h->slice_type_fixed=0;
4231
4232     slice_type= slice_type_map[ slice_type ];
4233     if (slice_type == I_TYPE
4234         || (h->slice_num != 0 && slice_type == h->slice_type) ) {
4235         default_ref_list_done = 1;
4236     }
4237     h->slice_type= slice_type;
4238
4239     s->pict_type= h->slice_type; // to make a few old func happy, it's wrong though
4240
4241     pps_id= get_ue_golomb(&s->gb);
4242     if(pps_id>255){
4243         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
4244         return -1;
4245     }
4246     h->pps= h->pps_buffer[pps_id];
4247     if(h->pps.slice_group_count == 0){
4248         av_log(h->s.avctx, AV_LOG_ERROR, "non existing PPS referenced\n");
4249         return -1;
4250     }
4251
4252     h->sps= h->sps_buffer[ h->pps.sps_id ];
4253     if(h->sps.log2_max_frame_num == 0){
4254         av_log(h->s.avctx, AV_LOG_ERROR, "non existing SPS referenced\n");
4255         return -1;
4256     }
4257
4258     if(h->dequant_coeff_pps != pps_id){
4259         h->dequant_coeff_pps = pps_id;
4260         init_dequant_tables(h);
4261     }
4262
4263     s->mb_width= h->sps.mb_width;
4264     s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
4265
4266     h->b_stride=  s->mb_width*4 + 1;
4267     h->b8_stride= s->mb_width*2 + 1;
4268
4269     s->width = 16*s->mb_width - 2*(h->sps.crop_left + h->sps.crop_right );
4270     if(h->sps.frame_mbs_only_flag)
4271         s->height= 16*s->mb_height - 2*(h->sps.crop_top  + h->sps.crop_bottom);
4272     else
4273         s->height= 16*s->mb_height - 4*(h->sps.crop_top  + h->sps.crop_bottom); //FIXME recheck
4274
4275     if (s->context_initialized
4276         && (   s->width != s->avctx->width || s->height != s->avctx->height)) {
4277         free_tables(h);
4278         MPV_common_end(s);
4279     }
4280     if (!s->context_initialized) {
4281         if (MPV_common_init(s) < 0)
4282             return -1;
4283
4284         if(s->dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly
4285             memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t));
4286             memcpy(h-> field_scan,  field_scan, 16*sizeof(uint8_t));
4287         }else{
4288             int i;
4289             for(i=0; i<16; i++){
4290 #define T(x) (x>>2) | ((x<<2) & 0xF)
4291                 h->zigzag_scan[i] = T(zigzag_scan[i]);
4292                 h-> field_scan[i] = T( field_scan[i]);
4293             }
4294         }
4295         if(h->sps.transform_bypass){ //FIXME same ugly
4296             h->zigzag_scan_q0 = zigzag_scan;
4297             h->field_scan_q0 = field_scan;
4298         }else{
4299             h->zigzag_scan_q0 = h->zigzag_scan;
4300             h->field_scan_q0 = h->field_scan;
4301         }
4302
4303         alloc_tables(h);
4304
4305         s->avctx->width = s->width;
4306         s->avctx->height = s->height;
4307         s->avctx->sample_aspect_ratio= h->sps.sar;
4308         if(!s->avctx->sample_aspect_ratio.den)
4309             s->avctx->sample_aspect_ratio.den = 1;
4310
4311         if(h->sps.timing_info_present_flag){
4312             s->avctx->time_base= (AVRational){h->sps.num_units_in_tick, h->sps.time_scale};
4313         }
4314     }
4315
4316     if(h->slice_num == 0){
4317         if(frame_start(h) < 0)
4318             return -1;
4319     }
4320
4321     s->current_picture_ptr->frame_num= //FIXME frame_num cleanup
4322     h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
4323
4324     h->mb_aff_frame = 0;
4325     if(h->sps.frame_mbs_only_flag){
4326         s->picture_structure= PICT_FRAME;
4327     }else{
4328         if(get_bits1(&s->gb)) { //field_pic_flag
4329             s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
4330         } else {
4331             s->picture_structure= PICT_FRAME;
4332             first_mb_in_slice <<= h->sps.mb_aff;
4333             h->mb_aff_frame = h->sps.mb_aff;
4334         }
4335     }
4336
4337     s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
4338     s->resync_mb_y = s->mb_y = first_mb_in_slice / s->mb_width;
4339     if(s->mb_y >= s->mb_height){
4340         return -1;
4341     }
4342
4343     if(s->picture_structure==PICT_FRAME){
4344         h->curr_pic_num=   h->frame_num;
4345         h->max_pic_num= 1<< h->sps.log2_max_frame_num;
4346     }else{
4347         h->curr_pic_num= 2*h->frame_num;
4348         h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
4349     }
4350
4351     if(h->nal_unit_type == NAL_IDR_SLICE){
4352         get_ue_golomb(&s->gb); /* idr_pic_id */
4353     }
4354
4355     if(h->sps.poc_type==0){
4356         h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
4357
4358         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
4359             h->delta_poc_bottom= get_se_golomb(&s->gb);
4360         }
4361     }
4362
4363     if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
4364         h->delta_poc[0]= get_se_golomb(&s->gb);
4365
4366         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
4367             h->delta_poc[1]= get_se_golomb(&s->gb);
4368     }
4369
4370     init_poc(h);
4371
4372     if(h->pps.redundant_pic_cnt_present){
4373         h->redundant_pic_count= get_ue_golomb(&s->gb);
4374     }
4375
4376     //set defaults, might be overriden a few line later
4377     h->ref_count[0]= h->pps.ref_count[0];
4378     h->ref_count[1]= h->pps.ref_count[1];
4379
4380     if(h->slice_type == P_TYPE || h->slice_type == SP_TYPE || h->slice_type == B_TYPE){
4381         if(h->slice_type == B_TYPE){
4382             h->direct_spatial_mv_pred= get_bits1(&s->gb);
4383         }
4384         num_ref_idx_active_override_flag= get_bits1(&s->gb);
4385
4386         if(num_ref_idx_active_override_flag){
4387             h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
4388             if(h->slice_type==B_TYPE)
4389                 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
4390
4391             if(h->ref_count[0] > 32 || h->ref_count[1] > 32){
4392                 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
4393                 return -1;
4394             }
4395         }
4396     }
4397
4398     if(!default_ref_list_done){
4399         fill_default_ref_list(h);
4400     }
4401
4402     if(decode_ref_pic_list_reordering(h) < 0)
4403         return -1;
4404
4405     if(   (h->pps.weighted_pred          && (h->slice_type == P_TYPE || h->slice_type == SP_TYPE ))
4406        || (h->pps.weighted_bipred_idc==1 && h->slice_type==B_TYPE ) )
4407         pred_weight_table(h);
4408     else if(h->pps.weighted_bipred_idc==2 && h->slice_type==B_TYPE)
4409         implicit_weight_table(h);
4410     else
4411         h->use_weight = 0;
4412
4413     if(s->current_picture.reference)
4414         decode_ref_pic_marking(h);
4415
4416     if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE && h->pps.cabac )
4417         h->cabac_init_idc = get_ue_golomb(&s->gb);
4418
4419     h->last_qscale_diff = 0;
4420     s->qscale = h->pps.init_qp + get_se_golomb(&s->gb);
4421     if(s->qscale<0 || s->qscale>51){
4422         av_log(s->avctx, AV_LOG_ERROR, "QP %d out of range\n", s->qscale);
4423         return -1;
4424     }
4425     h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
4426     //FIXME qscale / qp ... stuff
4427     if(h->slice_type == SP_TYPE){
4428         get_bits1(&s->gb); /* sp_for_switch_flag */
4429     }
4430     if(h->slice_type==SP_TYPE || h->slice_type == SI_TYPE){
4431         get_se_golomb(&s->gb); /* slice_qs_delta */
4432     }
4433
4434     h->deblocking_filter = 1;
4435     h->slice_alpha_c0_offset = 0;
4436     h->slice_beta_offset = 0;
4437     if( h->pps.deblocking_filter_parameters_present ) {
4438         h->deblocking_filter= get_ue_golomb(&s->gb);
4439         if(h->deblocking_filter < 2)
4440             h->deblocking_filter^= 1; // 1<->0
4441
4442         if( h->deblocking_filter ) {
4443             h->slice_alpha_c0_offset = get_se_golomb(&s->gb) << 1;
4444             h->slice_beta_offset = get_se_golomb(&s->gb) << 1;
4445         }
4446     }
4447     if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
4448        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type != I_TYPE)
4449        ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type == B_TYPE)
4450        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
4451         h->deblocking_filter= 0;
4452
4453 #if 0 //FMO
4454     if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
4455         slice_group_change_cycle= get_bits(&s->gb, ?);
4456 #endif
4457
4458     h->slice_num++;
4459
4460     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
4461         av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c pps:%d frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s\n",
4462                h->slice_num,
4463                (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
4464                first_mb_in_slice,
4465                av_get_pict_type_char(h->slice_type),
4466                pps_id, h->frame_num,
4467                s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
4468                h->ref_count[0], h->ref_count[1],
4469                s->qscale,
4470                h->deblocking_filter, h->slice_alpha_c0_offset/2, h->slice_beta_offset/2,
4471                h->use_weight,
4472                h->use_weight==1 && h->use_weight_chroma ? "c" : ""
4473                );
4474     }
4475
4476     return 0;
4477 }
4478
4479 /**
4480  *
4481  */
4482 static inline int get_level_prefix(GetBitContext *gb){
4483     unsigned int buf;
4484     int log;
4485
4486     OPEN_READER(re, gb);
4487     UPDATE_CACHE(re, gb);
4488     buf=GET_CACHE(re, gb);
4489
4490     log= 32 - av_log2(buf);
4491 #ifdef TRACE
4492     print_bin(buf>>(32-log), log);
4493     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__);
4494 #endif
4495
4496     LAST_SKIP_BITS(re, gb, log);
4497     CLOSE_READER(re, gb);
4498
4499     return log-1;
4500 }
4501
4502 static inline int get_dct8x8_allowed(H264Context *h){
4503     int i;
4504     for(i=0; i<4; i++){
4505         if(!IS_SUB_8X8(h->sub_mb_type[i])
4506            || (!h->sps.direct_8x8_inference_flag && IS_DIRECT(h->sub_mb_type[i])))
4507             return 0;
4508     }
4509     return 1;
4510 }
4511
4512 /**
4513  * decodes a residual block.
4514  * @param n block index
4515  * @param scantable scantable
4516  * @param max_coeff number of coefficients in the block
4517  * @return <0 if an error occured
4518  */
4519 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
4520     MpegEncContext * const s = &h->s;
4521     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};
4522     int level[16];
4523     int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
4524
4525     //FIXME put trailing_onex into the context
4526
4527     if(n == CHROMA_DC_BLOCK_INDEX){
4528         coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
4529         total_coeff= coeff_token>>2;
4530     }else{
4531         if(n == LUMA_DC_BLOCK_INDEX){
4532             total_coeff= pred_non_zero_count(h, 0);
4533             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
4534             total_coeff= coeff_token>>2;
4535         }else{
4536             total_coeff= pred_non_zero_count(h, n);
4537             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
4538             total_coeff= coeff_token>>2;
4539             h->non_zero_count_cache[ scan8[n] ]= total_coeff;
4540         }
4541     }
4542
4543     //FIXME set last_non_zero?
4544
4545     if(total_coeff==0)
4546         return 0;
4547
4548     trailing_ones= coeff_token&3;
4549     tprintf("trailing:%d, total:%d\n", trailing_ones, total_coeff);
4550     assert(total_coeff<=16);
4551
4552     for(i=0; i<trailing_ones; i++){
4553         level[i]= 1 - 2*get_bits1(gb);
4554     }
4555
4556     if(i<total_coeff) {
4557         int level_code, mask;
4558         int suffix_length = total_coeff > 10 && trailing_ones < 3;
4559         int prefix= get_level_prefix(gb);
4560
4561         //first coefficient has suffix_length equal to 0 or 1
4562         if(prefix<14){ //FIXME try to build a large unified VLC table for all this
4563             if(suffix_length)
4564                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4565             else
4566                 level_code= (prefix<<suffix_length); //part
4567         }else if(prefix==14){
4568             if(suffix_length)
4569                 level_code= (prefix<<suffix_length) + get_bits(gb, suffix_length); //part
4570             else
4571                 level_code= prefix + get_bits(gb, 4); //part
4572         }else if(prefix==15){
4573             level_code= (prefix<<suffix_length) + get_bits(gb, 12); //part
4574             if(suffix_length==0) level_code+=15; //FIXME doesn't make (much)sense
4575         }else{
4576             av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
4577             return -1;
4578         }
4579
4580         if(trailing_ones < 3) level_code += 2;
4581
4582         suffix_length = 1;
4583         if(level_code > 5)
4584             suffix_length++;
4585         mask= -(level_code&1);
4586         level[i]= (((2+level_code)>>1) ^ mask) - mask;
4587         i++;
4588
4589         //remaining coefficients have suffix_length > 0
4590         for(;i<total_coeff;i++) {
4591             static const int suffix_limit[7] = {0,5,11,23,47,95,INT_MAX };
4592             prefix = get_level_prefix(gb);
4593             if(prefix<15){
4594                 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
4595             }else if(prefix==15){
4596                 level_code =  (prefix<<suffix_length) + get_bits(gb, 12);
4597             }else{
4598                 av_log(h->s.avctx, AV_LOG_ERROR, "prefix too large at %d %d\n", s->mb_x, s->mb_y);
4599                 return -1;
4600             }
4601             mask= -(level_code&1);
4602             level[i]= (((2+level_code)>>1) ^ mask) - mask;
4603             if(level_code > suffix_limit[suffix_length])
4604                 suffix_length++;
4605         }
4606     }
4607
4608     if(total_coeff == max_coeff)
4609         zeros_left=0;
4610     else{
4611         if(n == CHROMA_DC_BLOCK_INDEX)
4612             zeros_left= get_vlc2(gb, chroma_dc_total_zeros_vlc[ total_coeff-1 ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
4613         else
4614             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff-1 ].table, TOTAL_ZEROS_VLC_BITS, 1);
4615     }
4616
4617     coeff_num = zeros_left + total_coeff - 1;
4618     j = scantable[coeff_num];
4619     if(n > 24){
4620         block[j] = level[0];
4621         for(i=1;i<total_coeff;i++) {
4622             if(zeros_left <= 0)
4623                 run_before = 0;
4624             else if(zeros_left < 7){
4625                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
4626             }else{
4627                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
4628             }
4629             zeros_left -= run_before;
4630             coeff_num -= 1 + run_before;
4631             j= scantable[ coeff_num ];
4632
4633             block[j]= level[i];
4634         }
4635     }else{
4636         block[j] = (level[0] * qmul[j] + 32)>>6;
4637         for(i=1;i<total_coeff;i++) {
4638             if(zeros_left <= 0)
4639                 run_before = 0;
4640             else if(zeros_left < 7){
4641                 run_before= get_vlc2(gb, run_vlc[zeros_left-1].table, RUN_VLC_BITS, 1);
4642             }else{
4643                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
4644             }
4645             zeros_left -= run_before;
4646             coeff_num -= 1 + run_before;
4647             j= scantable[ coeff_num ];
4648
4649             block[j]= (level[i] * qmul[j] + 32)>>6;
4650         }
4651     }
4652
4653     if(zeros_left<0){
4654         av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
4655         return -1;
4656     }
4657
4658     return 0;
4659 }
4660
4661 /**
4662  * decodes a P_SKIP or B_SKIP macroblock
4663  */
4664 static void decode_mb_skip(H264Context *h){
4665     MpegEncContext * const s = &h->s;
4666     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
4667     int mb_type=0;
4668
4669     memset(h->non_zero_count[mb_xy], 0, 16);
4670     memset(h->non_zero_count_cache + 8, 0, 8*5); //FIXME ugly, remove pfui
4671
4672     if(h->mb_aff_frame && s->mb_skip_run==0 && (s->mb_y&1)==0){
4673         h->mb_field_decoding_flag= get_bits1(&s->gb);
4674     }
4675     if(h->mb_field_decoding_flag)
4676         mb_type|= MB_TYPE_INTERLACED;
4677
4678     if( h->slice_type == B_TYPE )
4679     {
4680         // just for fill_caches. pred_direct_motion will set the real mb_type
4681         mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2|MB_TYPE_SKIP;
4682
4683         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
4684         pred_direct_motion(h, &mb_type);
4685         if(h->pps.cabac){
4686             fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
4687             fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
4688         }
4689     }
4690     else
4691     {
4692         int mx, my;
4693         mb_type|= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P1L0|MB_TYPE_SKIP;
4694
4695         fill_caches(h, mb_type, 0); //FIXME check what is needed and what not ...
4696         pred_pskip_motion(h, &mx, &my);
4697         fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, 0, 1);
4698         fill_rectangle(  h->mv_cache[0][scan8[0]], 4, 4, 8, pack16to32(mx,my), 4);
4699         if(h->pps.cabac)
4700             fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
4701     }
4702
4703     write_back_motion(h, mb_type);
4704     s->current_picture.mb_type[mb_xy]= mb_type|MB_TYPE_SKIP;
4705     s->current_picture.qscale_table[mb_xy]= s->qscale;
4706     h->slice_table[ mb_xy ]= h->slice_num;
4707     h->prev_mb_skipped= 1;
4708 }
4709
4710 /**
4711  * decodes a macroblock
4712  * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
4713  */
4714 static int decode_mb_cavlc(H264Context *h){
4715     MpegEncContext * const s = &h->s;
4716     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
4717     int mb_type, partition_count, cbp;
4718     int dct8x8_allowed= h->pps.transform_8x8_mode;
4719
4720     s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?
4721
4722     tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
4723     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
4724                 down the code */
4725     if(h->slice_type != I_TYPE && h->slice_type != SI_TYPE){
4726         if(s->mb_skip_run==-1)
4727             s->mb_skip_run= get_ue_golomb(&s->gb);
4728
4729         if (s->mb_skip_run--) {
4730             decode_mb_skip(h);
4731             return 0;
4732         }
4733     }
4734     if(h->mb_aff_frame){
4735         if ( ((s->mb_y&1) == 0) || h->prev_mb_skipped)
4736             h->mb_field_decoding_flag = get_bits1(&s->gb);
4737     }else
4738         h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
4739
4740     h->prev_mb_skipped= 0;
4741
4742     mb_type= get_ue_golomb(&s->gb);
4743     if(h->slice_type == B_TYPE){
4744         if(mb_type < 23){
4745             partition_count= b_mb_type_info[mb_type].partition_count;
4746             mb_type=         b_mb_type_info[mb_type].type;
4747         }else{
4748             mb_type -= 23;
4749             goto decode_intra_mb;
4750         }
4751     }else if(h->slice_type == P_TYPE /*|| h->slice_type == SP_TYPE */){
4752         if(mb_type < 5){
4753             partition_count= p_mb_type_info[mb_type].partition_count;
4754             mb_type=         p_mb_type_info[mb_type].type;
4755         }else{
4756             mb_type -= 5;
4757             goto decode_intra_mb;
4758         }
4759     }else{
4760        assert(h->slice_type == I_TYPE);
4761 decode_intra_mb:
4762         if(mb_type > 25){
4763             av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice to large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
4764             return -1;
4765         }
4766         partition_count=0;
4767         cbp= i_mb_type_info[mb_type].cbp;
4768         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
4769         mb_type= i_mb_type_info[mb_type].type;
4770     }
4771
4772     if(h->mb_field_decoding_flag)
4773         mb_type |= MB_TYPE_INTERLACED;
4774
4775     h->slice_table[ mb_xy ]= h->slice_num;
4776
4777     if(IS_INTRA_PCM(mb_type)){
4778         unsigned int x, y;
4779
4780         // we assume these blocks are very rare so we dont optimize it
4781         align_get_bits(&s->gb);
4782
4783         // The pixels are stored in the same order as levels in h->mb array.
4784         for(y=0; y<16; y++){
4785             const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
4786             for(x=0; x<16; x++){
4787                 tprintf("LUMA ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
4788                 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= get_bits(&s->gb, 8);
4789             }
4790         }
4791         for(y=0; y<8; y++){
4792             const int index= 256 + 4*(y&3) + 32*(y>>2);
4793             for(x=0; x<8; x++){
4794                 tprintf("CHROMA U ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
4795                 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
4796             }
4797         }
4798         for(y=0; y<8; y++){
4799             const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
4800             for(x=0; x<8; x++){
4801                 tprintf("CHROMA V ICPM LEVEL (%3d)\n", show_bits(&s->gb, 8));
4802                 h->mb[index + (x&3) + 16*(x>>2)]= get_bits(&s->gb, 8);
4803             }
4804         }
4805
4806         // In deblocking, the quantizer is 0
4807         s->current_picture.qscale_table[mb_xy]= 0;
4808         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
4809         // All coeffs are present
4810         memset(h->non_zero_count[mb_xy], 16, 16);
4811
4812         s->current_picture.mb_type[mb_xy]= mb_type;
4813         return 0;
4814     }
4815
4816     fill_caches(h, mb_type, 0);
4817
4818     //mb_pred
4819     if(IS_INTRA(mb_type)){
4820 //            init_top_left_availability(h);
4821             if(IS_INTRA4x4(mb_type)){
4822                 int i;
4823                 int di = 1;
4824                 if(dct8x8_allowed && get_bits1(&s->gb)){
4825                     mb_type |= MB_TYPE_8x8DCT;
4826                     di = 4;
4827                 }
4828
4829 //                fill_intra4x4_pred_table(h);
4830                 for(i=0; i<16; i+=di){
4831                     const int mode_coded= !get_bits1(&s->gb);
4832                     const int predicted_mode=  pred_intra_mode(h, i);
4833                     int mode;
4834
4835                     if(mode_coded){
4836                         const int rem_mode= get_bits(&s->gb, 3);
4837                         if(rem_mode<predicted_mode)
4838                             mode= rem_mode;
4839                         else
4840                             mode= rem_mode + 1;
4841                     }else{
4842                         mode= predicted_mode;
4843                     }
4844
4845                     if(di==4)
4846                         fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
4847                     else
4848                         h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
4849                 }
4850                 write_back_intra_pred_mode(h);
4851                 if( check_intra4x4_pred_mode(h) < 0)
4852                     return -1;
4853             }else{
4854                 h->intra16x16_pred_mode= check_intra_pred_mode(h, h->intra16x16_pred_mode);
4855                 if(h->intra16x16_pred_mode < 0)
4856                     return -1;
4857             }
4858             h->chroma_pred_mode= get_ue_golomb(&s->gb);
4859
4860             h->chroma_pred_mode= check_intra_pred_mode(h, h->chroma_pred_mode);
4861             if(h->chroma_pred_mode < 0)
4862                 return -1;
4863     }else if(partition_count==4){
4864         int i, j, sub_partition_count[4], list, ref[2][4];
4865
4866         if(h->slice_type == B_TYPE){
4867             for(i=0; i<4; i++){
4868                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
4869                 if(h->sub_mb_type[i] >=13){
4870                     av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
4871                     return -1;
4872                 }
4873                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
4874                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
4875             }
4876             if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
4877                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
4878                 pred_direct_motion(h, &mb_type);
4879                 h->ref_cache[0][scan8[4]] =
4880                 h->ref_cache[1][scan8[4]] =
4881                 h->ref_cache[0][scan8[12]] =
4882                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
4883             }
4884         }else{
4885             assert(h->slice_type == P_TYPE || h->slice_type == SP_TYPE); //FIXME SP correct ?
4886             for(i=0; i<4; i++){
4887                 h->sub_mb_type[i]= get_ue_golomb(&s->gb);
4888                 if(h->sub_mb_type[i] >=4){
4889                     av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %d out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
4890                     return -1;
4891                 }
4892                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
4893                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
4894             }
4895         }
4896
4897         for(list=0; list<2; list++){
4898             int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
4899             if(ref_count == 0) continue;
4900             if (h->mb_aff_frame && h->mb_field_decoding_flag) {
4901                 ref_count <<= 1;
4902             }
4903             for(i=0; i<4; i++){
4904                 if(IS_DIRECT(h->sub_mb_type[i])) continue;
4905                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
4906                     ref[list][i] = get_te0_golomb(&s->gb, ref_count); //FIXME init to 0 before and skip?
4907                 }else{
4908                  //FIXME
4909                     ref[list][i] = -1;
4910                 }
4911             }
4912         }
4913
4914         if(dct8x8_allowed)
4915             dct8x8_allowed = get_dct8x8_allowed(h);
4916
4917         for(list=0; list<2; list++){
4918             const int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
4919             if(ref_count == 0) continue;
4920
4921             for(i=0; i<4; i++){
4922                 if(IS_DIRECT(h->sub_mb_type[i])) {
4923                     h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
4924                     continue;
4925                 }
4926                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
4927                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
4928
4929                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
4930                     const int sub_mb_type= h->sub_mb_type[i];
4931                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
4932                     for(j=0; j<sub_partition_count[i]; j++){
4933                         int mx, my;
4934                         const int index= 4*i + block_width*j;
4935                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
4936                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
4937                         mx += get_se_golomb(&s->gb);
4938                         my += get_se_golomb(&s->gb);
4939                         tprintf("final mv:%d %d\n", mx, my);
4940
4941                         if(IS_SUB_8X8(sub_mb_type)){
4942                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
4943                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
4944                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
4945                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
4946                         }else if(IS_SUB_8X4(sub_mb_type)){
4947                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
4948                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
4949                         }else if(IS_SUB_4X8(sub_mb_type)){
4950                             mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
4951                             mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
4952                         }else{
4953                             assert(IS_SUB_4X4(sub_mb_type));
4954                             mv_cache[ 0 ][0]= mx;
4955                             mv_cache[ 0 ][1]= my;
4956                         }
4957                     }
4958                 }else{
4959                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
4960                     p[0] = p[1]=
4961                     p[8] = p[9]= 0;
4962                 }
4963             }
4964         }
4965     }else if(IS_DIRECT(mb_type)){
4966         pred_direct_motion(h, &mb_type);
4967         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
4968     }else{
4969         int list, mx, my, i;
4970          //FIXME we should set ref_idx_l? to 0 if we use that later ...
4971         if(IS_16X16(mb_type)){
4972             for(list=0; list<2; list++){
4973                 if(h->ref_count[list]>0){
4974                     if(IS_DIR(mb_type, 0, list)){
4975                         const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
4976                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
4977                     }else
4978                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (LIST_NOT_USED&0xFF), 1);
4979                 }
4980             }
4981             for(list=0; list<2; list++){
4982                 if(IS_DIR(mb_type, 0, list)){
4983                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
4984                     mx += get_se_golomb(&s->gb);
4985                     my += get_se_golomb(&s->gb);
4986                     tprintf("final mv:%d %d\n", mx, my);
4987
4988                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
4989                 }else
4990                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
4991             }
4992         }
4993         else if(IS_16X8(mb_type)){
4994             for(list=0; list<2; list++){
4995                 if(h->ref_count[list]>0){
4996                     for(i=0; i<2; i++){
4997                         if(IS_DIR(mb_type, i, list)){
4998                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
4999                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
5000                         }else
5001                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
5002                     }
5003                 }
5004             }
5005             for(list=0; list<2; list++){
5006                 for(i=0; i<2; i++){
5007                     if(IS_DIR(mb_type, i, list)){
5008                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
5009                         mx += get_se_golomb(&s->gb);
5010                         my += get_se_golomb(&s->gb);
5011                         tprintf("final mv:%d %d\n", mx, my);
5012
5013                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
5014                     }else
5015                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
5016                 }
5017             }
5018         }else{
5019             assert(IS_8X16(mb_type));
5020             for(list=0; list<2; list++){
5021                 if(h->ref_count[list]>0){
5022                     for(i=0; i<2; i++){
5023                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
5024                             const int val= get_te0_golomb(&s->gb, h->ref_count[list]);
5025                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
5026                         }else
5027                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
5028                     }
5029                 }
5030             }
5031             for(list=0; list<2; list++){
5032                 for(i=0; i<2; i++){
5033                     if(IS_DIR(mb_type, i, list)){
5034                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
5035                         mx += get_se_golomb(&s->gb);
5036                         my += get_se_golomb(&s->gb);
5037                         tprintf("final mv:%d %d\n", mx, my);
5038
5039                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
5040                     }else
5041                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
5042                 }
5043             }
5044         }
5045     }
5046
5047     if(IS_INTER(mb_type))
5048         write_back_motion(h, mb_type);
5049
5050     if(!IS_INTRA16x16(mb_type)){
5051         cbp= get_ue_golomb(&s->gb);
5052         if(cbp > 47){
5053             av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%d) at %d %d\n", cbp, s->mb_x, s->mb_y);
5054             return -1;
5055         }
5056
5057         if(IS_INTRA4x4(mb_type))
5058             cbp= golomb_to_intra4x4_cbp[cbp];
5059         else
5060             cbp= golomb_to_inter_cbp[cbp];
5061     }
5062
5063     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
5064         if(get_bits1(&s->gb))
5065             mb_type |= MB_TYPE_8x8DCT;
5066     }
5067     s->current_picture.mb_type[mb_xy]= mb_type;
5068
5069     if(cbp || IS_INTRA16x16(mb_type)){
5070         int i8x8, i4x4, chroma_idx;
5071         int chroma_qp, dquant;
5072         GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
5073         const uint8_t *scan, *dc_scan;
5074
5075 //        fill_non_zero_count_cache(h);
5076
5077         if(IS_INTERLACED(mb_type)){
5078             scan= s->qscale ? h->field_scan : h->field_scan_q0;
5079             dc_scan= luma_dc_field_scan;
5080         }else{
5081             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
5082             dc_scan= luma_dc_zigzag_scan;
5083         }
5084
5085         dquant= get_se_golomb(&s->gb);
5086
5087         if( dquant > 25 || dquant < -26 ){
5088             av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
5089             return -1;
5090         }
5091
5092         s->qscale += dquant;
5093         if(((unsigned)s->qscale) > 51){
5094             if(s->qscale<0) s->qscale+= 52;
5095             else            s->qscale-= 52;
5096         }
5097
5098         h->chroma_qp= chroma_qp= get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
5099         if(IS_INTRA16x16(mb_type)){
5100             if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
5101                 return -1; //FIXME continue if partitioned and other return -1 too
5102             }
5103
5104             assert((cbp&15) == 0 || (cbp&15) == 15);
5105
5106             if(cbp&15){
5107                 for(i8x8=0; i8x8<4; i8x8++){
5108                     for(i4x4=0; i4x4<4; i4x4++){
5109                         const int index= i4x4 + 4*i8x8;
5110                         if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
5111                             return -1;
5112                         }
5113                     }
5114                 }
5115             }else{
5116                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
5117             }
5118         }else{
5119             for(i8x8=0; i8x8<4; i8x8++){
5120                 if(cbp & (1<<i8x8)){
5121                     if(IS_8x8DCT(mb_type)){
5122                         DCTELEM *buf = &h->mb[64*i8x8];
5123                         uint8_t *nnz;
5124                         for(i4x4=0; i4x4<4; i4x4++){
5125                             if( decode_residual(h, gb, buf, i4x4+4*i8x8, zigzag_scan8x8_cavlc+16*i4x4,
5126                                                 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
5127                                 return -1;
5128                         }
5129                         nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
5130                         nnz[0] |= nnz[1] | nnz[8] | nnz[9];
5131                     }else{
5132                         for(i4x4=0; i4x4<4; i4x4++){
5133                             const int index= i4x4 + 4*i8x8;
5134
5135                             if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
5136                                 return -1;
5137                             }
5138                         }
5139                     }
5140                 }else{
5141                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
5142                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
5143                 }
5144             }
5145         }
5146
5147         if(cbp&0x30){
5148             for(chroma_idx=0; chroma_idx<2; chroma_idx++)
5149                 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
5150                     return -1;
5151                 }
5152         }
5153
5154         if(cbp&0x20){
5155             for(chroma_idx=0; chroma_idx<2; chroma_idx++){
5156                 for(i4x4=0; i4x4<4; i4x4++){
5157                     const int index= 16 + 4*chroma_idx + i4x4;
5158                     if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][chroma_qp], 15) < 0){
5159                         return -1;
5160                     }
5161                 }
5162             }
5163         }else{
5164             uint8_t * const nnz= &h->non_zero_count_cache[0];
5165             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
5166             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
5167         }
5168     }else{
5169         uint8_t * const nnz= &h->non_zero_count_cache[0];
5170         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
5171         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
5172         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
5173     }
5174     s->current_picture.qscale_table[mb_xy]= s->qscale;
5175     write_back_non_zero_count(h);
5176
5177     return 0;
5178 }
5179
5180 static int decode_cabac_field_decoding_flag(H264Context *h) {
5181     MpegEncContext * const s = &h->s;
5182     const int mb_x = s->mb_x;
5183     const int mb_y = s->mb_y & ~1;
5184     const int mba_xy = mb_x - 1 +  mb_y   *s->mb_stride;
5185     const int mbb_xy = mb_x     + (mb_y-2)*s->mb_stride;
5186
5187     unsigned int ctx = 0;
5188
5189     if( h->slice_table[mba_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mba_xy] ) ) {
5190         ctx += 1;
5191     }
5192     if( h->slice_table[mbb_xy] == h->slice_num && IS_INTERLACED( s->current_picture.mb_type[mbb_xy] ) ) {
5193         ctx += 1;
5194     }
5195
5196     return get_cabac( &h->cabac, &h->cabac_state[70 + ctx] );
5197 }
5198
5199 static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) {
5200     uint8_t *state= &h->cabac_state[ctx_base];
5201     int mb_type;
5202
5203     if(intra_slice){
5204         MpegEncContext * const s = &h->s;
5205         const int mba_xy = h->left_mb_xy[0];
5206         const int mbb_xy = h->top_mb_xy;
5207         int ctx=0;
5208         if( h->slice_table[mba_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mba_xy] ) )
5209             ctx++;
5210         if( h->slice_table[mbb_xy] == h->slice_num && !IS_INTRA4x4( s->current_picture.mb_type[mbb_xy] ) )
5211             ctx++;
5212         if( get_cabac( &h->cabac, &state[ctx] ) == 0 )
5213             return 0;   /* I4x4 */
5214         state += 2;
5215     }else{
5216         if( get_cabac( &h->cabac, &state[0] ) == 0 )
5217             return 0;   /* I4x4 */
5218     }
5219
5220     if( get_cabac_terminate( &h->cabac ) )
5221         return 25;  /* PCM */
5222
5223     mb_type = 1; /* I16x16 */
5224     if( get_cabac( &h->cabac, &state[1] ) )
5225         mb_type += 12;  /* cbp_luma != 0 */
5226
5227     if( get_cabac( &h->cabac, &state[2] ) ) {
5228         if( get_cabac( &h->cabac, &state[2+intra_slice] ) )
5229             mb_type += 4 * 2;   /* cbp_chroma == 2 */
5230         else
5231             mb_type += 4 * 1;   /* cbp_chroma == 1 */
5232     }
5233     if( get_cabac( &h->cabac, &state[3+intra_slice] ) )
5234         mb_type += 2;
5235     if( get_cabac( &h->cabac, &state[3+2*intra_slice] ) )
5236         mb_type += 1;
5237     return mb_type;
5238 }
5239
5240 static int decode_cabac_mb_type( H264Context *h ) {
5241     MpegEncContext * const s = &h->s;
5242
5243     if( h->slice_type == I_TYPE ) {
5244         return decode_cabac_intra_mb_type(h, 3, 1);
5245     } else if( h->slice_type == P_TYPE ) {
5246         if( get_cabac( &h->cabac, &h->cabac_state[14] ) == 0 ) {
5247             /* P-type */
5248             if( get_cabac( &h->cabac, &h->cabac_state[15] ) == 0 ) {
5249                 if( get_cabac( &h->cabac, &h->cabac_state[16] ) == 0 )
5250                     return 0; /* P_L0_D16x16; */
5251                 else
5252                     return 3; /* P_8x8; */
5253             } else {
5254                 if( get_cabac( &h->cabac, &h->cabac_state[17] ) == 0 )
5255                     return 2; /* P_L0_D8x16; */
5256                 else
5257                     return 1; /* P_L0_D16x8; */
5258             }
5259         } else {
5260             return decode_cabac_intra_mb_type(h, 17, 0) + 5;
5261         }
5262     } else if( h->slice_type == B_TYPE ) {
5263         const int mba_xy = h->left_mb_xy[0];
5264         const int mbb_xy = h->top_mb_xy;
5265         int ctx = 0;
5266         int bits;
5267
5268         if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] )
5269                       && !IS_DIRECT( s->current_picture.mb_type[mba_xy] ) )
5270             ctx++;
5271         if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] )
5272                       && !IS_DIRECT( s->current_picture.mb_type[mbb_xy] ) )
5273             ctx++;
5274
5275         if( !get_cabac( &h->cabac, &h->cabac_state[27+ctx] ) )
5276             return 0; /* B_Direct_16x16 */
5277
5278         if( !get_cabac( &h->cabac, &h->cabac_state[27+3] ) ) {
5279             return 1 + get_cabac( &h->cabac, &h->cabac_state[27+5] ); /* B_L[01]_16x16 */
5280         }
5281
5282         bits = get_cabac( &h->cabac, &h->cabac_state[27+4] ) << 3;
5283         bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 2;
5284         bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] ) << 1;
5285         bits|= get_cabac( &h->cabac, &h->cabac_state[27+5] );
5286         if( bits < 8 )
5287             return bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
5288         else if( bits == 13 ) {
5289             return decode_cabac_intra_mb_type(h, 32, 0) + 23;
5290         } else if( bits == 14 )
5291             return 11; /* B_L1_L0_8x16 */
5292         else if( bits == 15 )
5293             return 22; /* B_8x8 */
5294
5295         bits= ( bits<<1 ) | get_cabac( &h->cabac, &h->cabac_state[27+5] );
5296         return bits - 4; /* B_L0_Bi_* through B_Bi_Bi_* */
5297     } else {
5298         /* TODO SI/SP frames? */
5299         return -1;
5300     }
5301 }
5302
5303 static int decode_cabac_mb_skip( H264Context *h) {
5304     MpegEncContext * const s = &h->s;
5305     const int mb_xy = s->mb_x + s->mb_y*s->mb_stride;
5306     const int mba_xy = mb_xy - 1;
5307     const int mbb_xy = mb_xy - s->mb_stride;
5308     int ctx = 0;
5309
5310     if( h->slice_table[mba_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mba_xy] ))
5311         ctx++;
5312     if( h->slice_table[mbb_xy] == h->slice_num && !IS_SKIP( s->current_picture.mb_type[mbb_xy] ))
5313         ctx++;
5314
5315     if( h->slice_type == P_TYPE || h->slice_type == SP_TYPE)
5316         return get_cabac( &h->cabac, &h->cabac_state[11+ctx] );
5317     else /* B-frame */
5318         return get_cabac( &h->cabac, &h->cabac_state[24+ctx] );
5319 }
5320
5321 static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
5322     int mode = 0;
5323
5324     if( get_cabac( &h->cabac, &h->cabac_state[68] ) )
5325         return pred_mode;
5326
5327     mode += 1 * get_cabac( &h->cabac, &h->cabac_state[69] );
5328     mode += 2 * get_cabac( &h->cabac, &h->cabac_state[69] );
5329     mode += 4 * get_cabac( &h->cabac, &h->cabac_state[69] );
5330
5331     if( mode >= pred_mode )
5332         return mode + 1;
5333     else
5334         return mode;
5335 }
5336
5337 static int decode_cabac_mb_chroma_pre_mode( H264Context *h) {
5338     const int mba_xy = h->left_mb_xy[0];
5339     const int mbb_xy = h->top_mb_xy;
5340
5341     int ctx = 0;
5342
5343     /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
5344     if( h->slice_table[mba_xy] == h->slice_num && h->chroma_pred_mode_table[mba_xy] != 0 )
5345         ctx++;
5346
5347     if( h->slice_table[mbb_xy] == h->slice_num && h->chroma_pred_mode_table[mbb_xy] != 0 )
5348         ctx++;
5349
5350     if( get_cabac( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
5351         return 0;
5352
5353     if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
5354         return 1;
5355     if( get_cabac( &h->cabac, &h->cabac_state[64+3] ) == 0 )
5356         return 2;
5357     else
5358         return 3;
5359 }
5360
5361 static const uint8_t block_idx_x[16] = {
5362     0, 1, 0, 1, 2, 3, 2, 3, 0, 1, 0, 1, 2, 3, 2, 3
5363 };
5364 static const uint8_t block_idx_y[16] = {
5365     0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 3, 3, 2, 2, 3, 3
5366 };
5367 static const uint8_t block_idx_xy[4][4] = {
5368     { 0, 2, 8,  10},
5369     { 1, 3, 9,  11},
5370     { 4, 6, 12, 14},
5371     { 5, 7, 13, 15}
5372 };
5373
5374 static int decode_cabac_mb_cbp_luma( H264Context *h) {
5375     MpegEncContext * const s = &h->s;
5376
5377     int cbp = 0;
5378     int i8x8;
5379
5380     for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
5381         int cbp_a = -1;
5382         int cbp_b = -1;
5383         int x, y;
5384         int ctx = 0;
5385
5386         x = block_idx_x[4*i8x8];
5387         y = block_idx_y[4*i8x8];
5388
5389         if( x > 0 )
5390             cbp_a = cbp;
5391         else if( s->mb_x > 0 && (h->slice_table[h->left_mb_xy[0]] == h->slice_num)) {
5392             cbp_a = h->left_cbp;
5393             tprintf("cbp_a = left_cbp = %x\n", cbp_a);
5394         }
5395
5396         if( y > 0 )
5397             cbp_b = cbp;
5398         else if( s->mb_y > 0 && (h->slice_table[h->top_mb_xy] == h->slice_num)) {
5399             cbp_b = h->top_cbp;
5400             tprintf("cbp_b = top_cbp = %x\n", cbp_b);
5401         }
5402
5403         /* No need to test for skip as we put 0 for skip block */
5404         /* No need to test for IPCM as we put 1 for IPCM block */
5405         if( cbp_a >= 0 ) {
5406             int i8x8a = block_idx_xy[(x-1)&0x03][y]/4;
5407             if( ((cbp_a >> i8x8a)&0x01) == 0 )
5408                 ctx++;
5409         }
5410
5411         if( cbp_b >= 0 ) {
5412             int i8x8b = block_idx_xy[x][(y-1)&0x03]/4;
5413             if( ((cbp_b >> i8x8b)&0x01) == 0 )
5414                 ctx += 2;
5415         }
5416
5417         if( get_cabac( &h->cabac, &h->cabac_state[73 + ctx] ) ) {
5418             cbp |= 1 << i8x8;
5419         }
5420     }
5421     return cbp;
5422 }
5423 static int decode_cabac_mb_cbp_chroma( H264Context *h) {
5424     int ctx;
5425     int cbp_a, cbp_b;
5426
5427     cbp_a = (h->left_cbp>>4)&0x03;
5428     cbp_b = (h-> top_cbp>>4)&0x03;
5429
5430     ctx = 0;
5431     if( cbp_a > 0 ) ctx++;
5432     if( cbp_b > 0 ) ctx += 2;
5433     if( get_cabac( &h->cabac, &h->cabac_state[77 + ctx] ) == 0 )
5434         return 0;
5435
5436     ctx = 4;
5437     if( cbp_a == 2 ) ctx++;
5438     if( cbp_b == 2 ) ctx += 2;
5439     return 1 + get_cabac( &h->cabac, &h->cabac_state[77 + ctx] );
5440 }
5441 static int decode_cabac_mb_dqp( H264Context *h) {
5442     MpegEncContext * const s = &h->s;
5443     int mbn_xy;
5444     int   ctx = 0;
5445     int   val = 0;
5446
5447     if( s->mb_x > 0 )
5448         mbn_xy = s->mb_x + s->mb_y*s->mb_stride - 1;
5449     else
5450         mbn_xy = s->mb_width - 1 + (s->mb_y-1)*s->mb_stride;
5451
5452     if( h->last_qscale_diff != 0 && ( IS_INTRA16x16(s->current_picture.mb_type[mbn_xy] ) || (h->cbp_table[mbn_xy]&0x3f) ) )
5453         ctx++;
5454
5455     while( get_cabac( &h->cabac, &h->cabac_state[60 + ctx] ) ) {
5456         if( ctx < 2 )
5457             ctx = 2;
5458         else
5459             ctx = 3;
5460         val++;
5461         if(val > 52) //prevent infinite loop
5462             return INT_MIN;
5463     }
5464
5465     if( val&0x01 )
5466         return (val + 1)/2;
5467     else
5468         return -(val + 1)/2;
5469 }
5470 static int decode_cabac_p_mb_sub_type( H264Context *h ) {
5471     if( get_cabac( &h->cabac, &h->cabac_state[21] ) )
5472         return 0;   /* 8x8 */
5473     if( !get_cabac( &h->cabac, &h->cabac_state[22] ) )
5474         return 1;   /* 8x4 */
5475     if( get_cabac( &h->cabac, &h->cabac_state[23] ) )
5476         return 2;   /* 4x8 */
5477     return 3;       /* 4x4 */
5478 }
5479 static int decode_cabac_b_mb_sub_type( H264Context *h ) {
5480     int type;
5481     if( !get_cabac( &h->cabac, &h->cabac_state[36] ) )
5482         return 0;   /* B_Direct_8x8 */
5483     if( !get_cabac( &h->cabac, &h->cabac_state[37] ) )
5484         return 1 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L0_8x8, B_L1_8x8 */
5485     type = 3;
5486     if( get_cabac( &h->cabac, &h->cabac_state[38] ) ) {
5487         if( get_cabac( &h->cabac, &h->cabac_state[39] ) )
5488             return 11 + get_cabac( &h->cabac, &h->cabac_state[39] ); /* B_L1_4x4, B_Bi_4x4 */
5489         type += 4;
5490     }
5491     type += 2*get_cabac( &h->cabac, &h->cabac_state[39] );
5492     type +=   get_cabac( &h->cabac, &h->cabac_state[39] );
5493     return type;
5494 }
5495
5496 static inline int decode_cabac_mb_transform_size( H264Context *h ) {
5497     return get_cabac( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
5498 }
5499
5500 static int decode_cabac_mb_ref( H264Context *h, int list, int n ) {
5501     int refa = h->ref_cache[list][scan8[n] - 1];
5502     int refb = h->ref_cache[list][scan8[n] - 8];
5503     int ref  = 0;
5504     int ctx  = 0;
5505
5506     if( h->slice_type == B_TYPE) {
5507         if( refa > 0 && !h->direct_cache[scan8[n] - 1] )
5508             ctx++;
5509         if( refb > 0 && !h->direct_cache[scan8[n] - 8] )
5510             ctx += 2;
5511     } else {
5512         if( refa > 0 )
5513             ctx++;
5514         if( refb > 0 )
5515             ctx += 2;
5516     }
5517
5518     while( get_cabac( &h->cabac, &h->cabac_state[54+ctx] ) ) {
5519         ref++;
5520         if( ctx < 4 )
5521             ctx = 4;
5522         else
5523             ctx = 5;
5524     }
5525     return ref;
5526 }
5527
5528 static int decode_cabac_mb_mvd( H264Context *h, int list, int n, int l ) {
5529     int amvd = abs( h->mvd_cache[list][scan8[n] - 1][l] ) +
5530                abs( h->mvd_cache[list][scan8[n] - 8][l] );
5531     int ctxbase = (l == 0) ? 40 : 47;
5532     int ctx, mvd;
5533
5534     if( amvd < 3 )
5535         ctx = 0;
5536     else if( amvd > 32 )
5537         ctx = 2;
5538     else
5539         ctx = 1;
5540
5541     if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+ctx]))
5542         return 0;
5543
5544     mvd= 1;
5545     ctx= 3;
5546     while( mvd < 9 && get_cabac( &h->cabac, &h->cabac_state[ctxbase+ctx] ) ) {
5547         mvd++;
5548         if( ctx < 6 )
5549             ctx++;
5550     }
5551
5552     if( mvd >= 9 ) {
5553         int k = 3;
5554         while( get_cabac_bypass( &h->cabac ) ) {
5555             mvd += 1 << k;
5556             k++;
5557         }
5558         while( k-- ) {
5559             if( get_cabac_bypass( &h->cabac ) )
5560                 mvd += 1 << k;
5561         }
5562     }
5563     if( get_cabac_bypass( &h->cabac ) )  return -mvd;
5564     else                                 return  mvd;
5565 }
5566
5567 static int inline get_cabac_cbf_ctx( H264Context *h, int cat, int idx ) {
5568     int nza, nzb;
5569     int ctx = 0;
5570
5571     if( cat == 0 ) {
5572         nza = h->left_cbp&0x100;
5573         nzb = h-> top_cbp&0x100;
5574     } else if( cat == 1 || cat == 2 ) {
5575         nza = h->non_zero_count_cache[scan8[idx] - 1];
5576         nzb = h->non_zero_count_cache[scan8[idx] - 8];
5577     } else if( cat == 3 ) {
5578         nza = (h->left_cbp>>(6+idx))&0x01;
5579         nzb = (h-> top_cbp>>(6+idx))&0x01;
5580     } else {
5581         assert(cat == 4);
5582         nza = h->non_zero_count_cache[scan8[16+idx] - 1];
5583         nzb = h->non_zero_count_cache[scan8[16+idx] - 8];
5584     }
5585
5586     if( nza > 0 )
5587         ctx++;
5588
5589     if( nzb > 0 )
5590         ctx += 2;
5591
5592     return ctx + 4 * cat;
5593 }
5594
5595 static int inline decode_cabac_residual( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff) {
5596     const int mb_xy  = h->s.mb_x + h->s.mb_y*h->s.mb_stride;
5597     static const int significant_coeff_flag_field_offset[2] = { 105, 277 };
5598     static const int last_significant_coeff_flag_field_offset[2] = { 166, 338 };
5599     static const int significant_coeff_flag_offset[6] = { 0, 15, 29, 44, 47, 297 };
5600     static const int last_significant_coeff_flag_offset[6] = { 0, 15, 29, 44, 47, 251 };
5601     static const int coeff_abs_level_m1_offset[6] = { 227+0, 227+10, 227+20, 227+30, 227+39, 426 };
5602     static const int significant_coeff_flag_offset_8x8[63] = {
5603         0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5,
5604         4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9,10, 9, 8, 7,
5605         7, 6,11,12,13,11, 6, 7, 8, 9,14,10, 9, 8, 6,11,
5606        12,13,11, 6, 9,14,10, 9,11,12,13,11,14,10,12
5607     };
5608     static const int last_coeff_flag_offset_8x8[63] = {
5609         0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
5610         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
5611         3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
5612         5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
5613     };
5614
5615     int index[64];
5616
5617     int i, last;
5618     int coeff_count = 0;
5619
5620     int abslevel1 = 1;
5621     int abslevelgt1 = 0;
5622
5623     uint8_t *significant_coeff_ctx_base;
5624     uint8_t *last_coeff_ctx_base;
5625     uint8_t *abs_level_m1_ctx_base;
5626
5627     /* cat: 0-> DC 16x16  n = 0
5628      *      1-> AC 16x16  n = luma4x4idx
5629      *      2-> Luma4x4   n = luma4x4idx
5630      *      3-> DC Chroma n = iCbCr
5631      *      4-> AC Chroma n = 4 * iCbCr + chroma4x4idx
5632      *      5-> Luma8x8   n = 4 * luma8x8idx
5633      */
5634
5635     /* read coded block flag */
5636     if( cat != 5 ) {
5637         if( get_cabac( &h->cabac, &h->cabac_state[85 + get_cabac_cbf_ctx( h, cat, n ) ] ) == 0 ) {
5638             if( cat == 1 || cat == 2 )
5639                 h->non_zero_count_cache[scan8[n]] = 0;
5640             else if( cat == 4 )
5641                 h->non_zero_count_cache[scan8[16+n]] = 0;
5642
5643             return 0;
5644         }
5645     }
5646
5647     significant_coeff_ctx_base = h->cabac_state
5648         + significant_coeff_flag_offset[cat]
5649         + significant_coeff_flag_field_offset[h->mb_field_decoding_flag];
5650     last_coeff_ctx_base = h->cabac_state
5651         + last_significant_coeff_flag_offset[cat]
5652         + last_significant_coeff_flag_field_offset[h->mb_field_decoding_flag];
5653     abs_level_m1_ctx_base = h->cabac_state
5654         + coeff_abs_level_m1_offset[cat];
5655
5656     if( cat == 5 ) {
5657 #define DECODE_SIGNIFICANCE( coefs, sig_off, last_off ) \
5658         for(last= 0; last < coefs; last++) { \
5659             uint8_t *sig_ctx = significant_coeff_ctx_base + sig_off; \
5660             if( get_cabac( &h->cabac, sig_ctx )) { \
5661                 uint8_t *last_ctx = last_coeff_ctx_base + last_off; \
5662                 index[coeff_count++] = last; \
5663                 if( get_cabac( &h->cabac, last_ctx ) ) { \
5664                     last= max_coeff; \
5665                     break; \
5666                 } \
5667             } \
5668         }
5669         DECODE_SIGNIFICANCE( 63, significant_coeff_flag_offset_8x8[last],
5670                                  last_coeff_flag_offset_8x8[last] );
5671     } else {
5672         DECODE_SIGNIFICANCE( max_coeff - 1, last, last );
5673     }
5674     if( last == max_coeff -1 ) {
5675         index[coeff_count++] = last;
5676     }
5677     assert(coeff_count > 0);
5678
5679     if( cat == 0 )
5680         h->cbp_table[mb_xy] |= 0x100;
5681     else if( cat == 1 || cat == 2 )
5682         h->non_zero_count_cache[scan8[n]] = coeff_count;
5683     else if( cat == 3 )
5684         h->cbp_table[mb_xy] |= 0x40 << n;
5685     else if( cat == 4 )
5686         h->non_zero_count_cache[scan8[16+n]] = coeff_count;
5687     else {
5688         assert( cat == 5 );
5689         fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, 1, 1);
5690     }
5691
5692     for( i = coeff_count - 1; i >= 0; i-- ) {
5693         uint8_t *ctx = (abslevelgt1 != 0 ? 0 : FFMIN( 4, abslevel1 )) + abs_level_m1_ctx_base;
5694         int j= scantable[index[i]];
5695
5696         if( get_cabac( &h->cabac, ctx ) == 0 ) {
5697             if( !qmul ) {
5698                 if( get_cabac_bypass( &h->cabac ) ) block[j] = -1;
5699                 else                                block[j] =  1;
5700             }else{
5701                 if( get_cabac_bypass( &h->cabac ) ) block[j] = (-qmul[j] + 32) >> 6;
5702                 else                                block[j] = ( qmul[j] + 32) >> 6;
5703             }
5704
5705             abslevel1++;
5706         } else {
5707             int coeff_abs = 2;
5708             ctx = 5 + FFMIN( 4, abslevelgt1 ) + abs_level_m1_ctx_base;
5709             while( coeff_abs < 15 && get_cabac( &h->cabac, ctx ) ) {
5710                 coeff_abs++;
5711             }
5712
5713             if( coeff_abs >= 15 ) {
5714                 int j = 0;
5715                 while( get_cabac_bypass( &h->cabac ) ) {
5716                     coeff_abs += 1 << j;
5717                     j++;
5718                 }
5719
5720                 while( j-- ) {
5721                     if( get_cabac_bypass( &h->cabac ) )
5722                         coeff_abs += 1 << j ;
5723                 }
5724             }
5725
5726             if( !qmul ) {
5727                 if( get_cabac_bypass( &h->cabac ) ) block[j] = -coeff_abs;
5728                 else                                block[j] =  coeff_abs;
5729             }else{
5730                 if( get_cabac_bypass( &h->cabac ) ) block[j] = (-coeff_abs * qmul[j] + 32) >> 6;
5731                 else                                block[j] = ( coeff_abs * qmul[j] + 32) >> 6;
5732             }
5733
5734             abslevelgt1++;
5735         }
5736     }
5737     return 0;
5738 }
5739
5740 void inline compute_mb_neighboors(H264Context *h)
5741 {
5742     MpegEncContext * const s = &h->s;
5743     const int mb_xy  = s->mb_x + s->mb_y*s->mb_stride;
5744     h->top_mb_xy     = mb_xy - s->mb_stride;
5745     h->left_mb_xy[0] = mb_xy - 1;
5746     if(h->mb_aff_frame){
5747         const int pair_xy          = s->mb_x     + (s->mb_y & ~1)*s->mb_stride;
5748         const int top_pair_xy      = pair_xy     - s->mb_stride;
5749         const int top_mb_frame_flag      = !IS_INTERLACED(s->current_picture.mb_type[top_pair_xy]);
5750         const int left_mb_frame_flag = !IS_INTERLACED(s->current_picture.mb_type[pair_xy-1]);
5751         const int curr_mb_frame_flag = !h->mb_field_decoding_flag;
5752         const int bottom = (s->mb_y & 1);
5753         if (bottom
5754                 ? !curr_mb_frame_flag // bottom macroblock
5755                 : (!curr_mb_frame_flag && !top_mb_frame_flag) // top macroblock
5756                 ) {
5757             h->top_mb_xy -= s->mb_stride;
5758         }
5759         if (left_mb_frame_flag != curr_mb_frame_flag) {
5760             h->left_mb_xy[0] = pair_xy - 1;
5761         }
5762     }
5763     return;
5764 }
5765
5766 /**
5767  * decodes a macroblock
5768  * @returns 0 if ok, AC_ERROR / DC_ERROR / MV_ERROR if an error is noticed
5769  */
5770 static int decode_mb_cabac(H264Context *h) {
5771     MpegEncContext * const s = &h->s;
5772     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
5773     int mb_type, partition_count, cbp = 0;
5774     int dct8x8_allowed= h->pps.transform_8x8_mode;
5775
5776     s->dsp.clear_blocks(h->mb); //FIXME avoid if already clear (move after skip handlong?)
5777
5778     tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
5779     if( h->slice_type != I_TYPE && h->slice_type != SI_TYPE ) {
5780         /* read skip flags */
5781         if( decode_cabac_mb_skip( h ) ) {
5782             decode_mb_skip(h);
5783
5784             h->cbp_table[mb_xy] = 0;
5785             h->chroma_pred_mode_table[mb_xy] = 0;
5786             h->last_qscale_diff = 0;
5787
5788             return 0;
5789
5790         }
5791     }
5792     if(h->mb_aff_frame){
5793         if ( ((s->mb_y&1) == 0) || h->prev_mb_skipped)
5794             h->mb_field_decoding_flag = decode_cabac_field_decoding_flag(h);
5795     }else
5796         h->mb_field_decoding_flag= (s->picture_structure!=PICT_FRAME);
5797
5798     h->prev_mb_skipped = 0;
5799
5800     compute_mb_neighboors(h);
5801     if( ( mb_type = decode_cabac_mb_type( h ) ) < 0 ) {
5802         av_log( h->s.avctx, AV_LOG_ERROR, "decode_cabac_mb_type failed\n" );
5803         return -1;
5804     }
5805
5806     if( h->slice_type == B_TYPE ) {
5807         if( mb_type < 23 ){
5808             partition_count= b_mb_type_info[mb_type].partition_count;
5809             mb_type=         b_mb_type_info[mb_type].type;
5810         }else{
5811             mb_type -= 23;
5812             goto decode_intra_mb;
5813         }
5814     } else if( h->slice_type == P_TYPE ) {
5815         if( mb_type < 5) {
5816             partition_count= p_mb_type_info[mb_type].partition_count;
5817             mb_type=         p_mb_type_info[mb_type].type;
5818         } else {
5819             mb_type -= 5;
5820             goto decode_intra_mb;
5821         }
5822     } else {
5823        assert(h->slice_type == I_TYPE);
5824 decode_intra_mb:
5825         partition_count = 0;
5826         cbp= i_mb_type_info[mb_type].cbp;
5827         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
5828         mb_type= i_mb_type_info[mb_type].type;
5829     }
5830     if(h->mb_field_decoding_flag)
5831         mb_type |= MB_TYPE_INTERLACED;
5832
5833     h->slice_table[ mb_xy ]= h->slice_num;
5834
5835     if(IS_INTRA_PCM(mb_type)) {
5836         const uint8_t *ptr;
5837         unsigned int x, y;
5838
5839         // We assume these blocks are very rare so we dont optimize it.
5840         // FIXME The two following lines get the bitstream position in the cabac
5841         // decode, I think it should be done by a function in cabac.h (or cabac.c).
5842         ptr= h->cabac.bytestream;
5843         if (h->cabac.low&0x1) ptr-=CABAC_BITS/8;
5844
5845         // The pixels are stored in the same order as levels in h->mb array.
5846         for(y=0; y<16; y++){
5847             const int index= 4*(y&3) + 32*((y>>2)&1) + 128*(y>>3);
5848             for(x=0; x<16; x++){
5849                 tprintf("LUMA ICPM LEVEL (%3d)\n", *ptr);
5850                 h->mb[index + (x&3) + 16*((x>>2)&1) + 64*(x>>3)]= *ptr++;
5851             }
5852         }
5853         for(y=0; y<8; y++){
5854             const int index= 256 + 4*(y&3) + 32*(y>>2);
5855             for(x=0; x<8; x++){
5856                 tprintf("CHROMA U ICPM LEVEL (%3d)\n", *ptr);
5857                 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
5858             }
5859         }
5860         for(y=0; y<8; y++){
5861             const int index= 256 + 64 + 4*(y&3) + 32*(y>>2);
5862             for(x=0; x<8; x++){
5863                 tprintf("CHROMA V ICPM LEVEL (%3d)\n", *ptr);
5864                 h->mb[index + (x&3) + 16*(x>>2)]= *ptr++;
5865             }
5866         }
5867
5868         ff_init_cabac_decoder(&h->cabac, ptr, h->cabac.bytestream_end - ptr);
5869
5870         // All blocks are present
5871         h->cbp_table[mb_xy] = 0x1ef;
5872         h->chroma_pred_mode_table[mb_xy] = 0;
5873         // In deblocking, the quantizer is 0
5874         s->current_picture.qscale_table[mb_xy]= 0;
5875         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, 0);
5876         // All coeffs are present
5877         memset(h->non_zero_count[mb_xy], 16, 16);
5878         s->current_picture.mb_type[mb_xy]= mb_type;
5879         return 0;
5880     }
5881
5882     fill_caches(h, mb_type, 0);
5883
5884     if( IS_INTRA( mb_type ) ) {
5885         int i;
5886         if( IS_INTRA4x4( mb_type ) ) {
5887             if( dct8x8_allowed && decode_cabac_mb_transform_size( h ) ) {
5888                 mb_type |= MB_TYPE_8x8DCT;
5889                 for( i = 0; i < 16; i+=4 ) {
5890                     int pred = pred_intra_mode( h, i );
5891                     int mode = decode_cabac_mb_intra4x4_pred_mode( h, pred );
5892                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
5893                 }
5894             } else {
5895                 for( i = 0; i < 16; i++ ) {
5896                     int pred = pred_intra_mode( h, i );
5897                     h->intra4x4_pred_mode_cache[ scan8[i] ] = decode_cabac_mb_intra4x4_pred_mode( h, pred );
5898
5899                 //av_log( s->avctx, AV_LOG_ERROR, "i4x4 pred=%d mode=%d\n", pred, h->intra4x4_pred_mode_cache[ scan8[i] ] );
5900                 }
5901             }
5902             write_back_intra_pred_mode(h);
5903             if( check_intra4x4_pred_mode(h) < 0 ) return -1;
5904         } else {
5905             h->intra16x16_pred_mode= check_intra_pred_mode( h, h->intra16x16_pred_mode );
5906             if( h->intra16x16_pred_mode < 0 ) return -1;
5907         }
5908         h->chroma_pred_mode_table[mb_xy] =
5909             h->chroma_pred_mode          = decode_cabac_mb_chroma_pre_mode( h );
5910
5911         h->chroma_pred_mode= check_intra_pred_mode( h, h->chroma_pred_mode );
5912         if( h->chroma_pred_mode < 0 ) return -1;
5913     } else if( partition_count == 4 ) {
5914         int i, j, sub_partition_count[4], list, ref[2][4];
5915
5916         if( h->slice_type == B_TYPE ) {
5917             for( i = 0; i < 4; i++ ) {
5918                 h->sub_mb_type[i] = decode_cabac_b_mb_sub_type( h );
5919                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
5920                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
5921             }
5922             if(   IS_DIRECT(h->sub_mb_type[0]) || IS_DIRECT(h->sub_mb_type[1])
5923                || IS_DIRECT(h->sub_mb_type[2]) || IS_DIRECT(h->sub_mb_type[3])) {
5924                 pred_direct_motion(h, &mb_type);
5925                 if( h->ref_count[0] > 1 || h->ref_count[1] > 1 ) {
5926                     for( i = 0; i < 4; i++ )
5927                         if( IS_DIRECT(h->sub_mb_type[i]) )
5928                             fill_rectangle( &h->direct_cache[scan8[4*i]], 2, 2, 8, 1, 1 );
5929                 }
5930             }
5931         } else {
5932             for( i = 0; i < 4; i++ ) {
5933                 h->sub_mb_type[i] = decode_cabac_p_mb_sub_type( h );
5934                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
5935                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
5936             }
5937         }
5938
5939         for( list = 0; list < 2; list++ ) {
5940             if( h->ref_count[list] > 0 ) {
5941                 for( i = 0; i < 4; i++ ) {
5942                     if(IS_DIRECT(h->sub_mb_type[i])) continue;
5943                     if(IS_DIR(h->sub_mb_type[i], 0, list)){
5944                         if( h->ref_count[list] > 1 )
5945                             ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
5946                         else
5947                             ref[list][i] = 0;
5948                     } else {
5949                         ref[list][i] = -1;
5950                     }
5951                                                        h->ref_cache[list][ scan8[4*i]+1 ]=
5952                     h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
5953                 }
5954             }
5955         }
5956
5957         if(dct8x8_allowed)
5958             dct8x8_allowed = get_dct8x8_allowed(h);
5959
5960         for(list=0; list<2; list++){
5961             for(i=0; i<4; i++){
5962                 if(IS_DIRECT(h->sub_mb_type[i])){
5963                     fill_rectangle(h->mvd_cache[list][scan8[4*i]], 2, 2, 8, 0, 4);
5964                     continue;
5965                 }
5966                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ];
5967
5968                 if(IS_DIR(h->sub_mb_type[i], 0, list) && !IS_DIRECT(h->sub_mb_type[i])){
5969                     const int sub_mb_type= h->sub_mb_type[i];
5970                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
5971                     for(j=0; j<sub_partition_count[i]; j++){
5972                         int mpx, mpy;
5973                         int mx, my;
5974                         const int index= 4*i + block_width*j;
5975                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
5976                         int16_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
5977                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mpx, &mpy);
5978
5979                         mx = mpx + decode_cabac_mb_mvd( h, list, index, 0 );
5980                         my = mpy + decode_cabac_mb_mvd( h, list, index, 1 );
5981                         tprintf("final mv:%d %d\n", mx, my);
5982
5983                         if(IS_SUB_8X8(sub_mb_type)){
5984                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]=
5985                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
5986                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]=
5987                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
5988
5989                             mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]=
5990                             mvd_cache[ 8 ][0]= mvd_cache[ 9 ][0]= mx - mpx;
5991                             mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]=
5992                             mvd_cache[ 8 ][1]= mvd_cache[ 9 ][1]= my - mpy;
5993                         }else if(IS_SUB_8X4(sub_mb_type)){
5994                             mv_cache[ 0 ][0]= mv_cache[ 1 ][0]= mx;
5995                             mv_cache[ 0 ][1]= mv_cache[ 1 ][1]= my;
5996
5997                             mvd_cache[ 0 ][0]= mvd_cache[ 1 ][0]= mx- mpx;
5998                             mvd_cache[ 0 ][1]= mvd_cache[ 1 ][1]= my - mpy;
5999                         }else if(IS_SUB_4X8(sub_mb_type)){
6000                             mv_cache[ 0 ][0]= mv_cache[ 8 ][0]= mx;
6001                             mv_cache[ 0 ][1]= mv_cache[ 8 ][1]= my;
6002
6003                             mvd_cache[ 0 ][0]= mvd_cache[ 8 ][0]= mx - mpx;
6004                             mvd_cache[ 0 ][1]= mvd_cache[ 8 ][1]= my - mpy;
6005                         }else{
6006                             assert(IS_SUB_4X4(sub_mb_type));
6007                             mv_cache[ 0 ][0]= mx;
6008                             mv_cache[ 0 ][1]= my;
6009
6010                             mvd_cache[ 0 ][0]= mx - mpx;
6011                             mvd_cache[ 0 ][1]= my - mpy;
6012                         }
6013                     }
6014                 }else{
6015                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
6016                     uint32_t *pd= (uint32_t *)&h->mvd_cache[list][ scan8[4*i] ][0];
6017                     p[0] = p[1] = p[8] = p[9] = 0;
6018                     pd[0]= pd[1]= pd[8]= pd[9]= 0;
6019                 }
6020             }
6021         }
6022     } else if( IS_DIRECT(mb_type) ) {
6023         pred_direct_motion(h, &mb_type);
6024         fill_rectangle(h->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 4);
6025         fill_rectangle(h->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 4);
6026         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
6027     } else {
6028         int list, mx, my, i, mpx, mpy;
6029         if(IS_16X16(mb_type)){
6030             for(list=0; list<2; list++){
6031                 if(IS_DIR(mb_type, 0, list)){
6032                     if(h->ref_count[list] > 0 ){
6033                         const int ref = h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 0 ) : 0;
6034                         fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, ref, 1);
6035                     }
6036                 }else
6037                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, (uint8_t)LIST_NOT_USED, 1);
6038             }
6039             for(list=0; list<2; list++){
6040                 if(IS_DIR(mb_type, 0, list)){
6041                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mpx, &mpy);
6042
6043                     mx = mpx + decode_cabac_mb_mvd( h, list, 0, 0 );
6044                     my = mpy + decode_cabac_mb_mvd( h, list, 0, 1 );
6045                     tprintf("final mv:%d %d\n", mx, my);
6046
6047                     fill_rectangle(h->mvd_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
6048                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
6049                 }else
6050                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, 0, 4);
6051             }
6052         }
6053         else if(IS_16X8(mb_type)){
6054             for(list=0; list<2; list++){
6055                 if(h->ref_count[list]>0){
6056                     for(i=0; i<2; i++){
6057                         if(IS_DIR(mb_type, i, list)){
6058                             const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 8*i ) : 0;
6059                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, ref, 1);
6060                         }else
6061                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, (LIST_NOT_USED&0xFF), 1);
6062                     }
6063                 }
6064             }
6065             for(list=0; list<2; list++){
6066                 for(i=0; i<2; i++){
6067                     if(IS_DIR(mb_type, i, list)){
6068                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mpx, &mpy);
6069                         mx = mpx + decode_cabac_mb_mvd( h, list, 8*i, 0 );
6070                         my = mpy + decode_cabac_mb_mvd( h, list, 8*i, 1 );
6071                         tprintf("final mv:%d %d\n", mx, my);
6072
6073                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx-mpx,my-mpy), 4);
6074                         fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, pack16to32(mx,my), 4);
6075                     }else{
6076                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
6077                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, 0, 4);
6078                     }
6079                 }
6080             }
6081         }else{
6082             assert(IS_8X16(mb_type));
6083             for(list=0; list<2; list++){
6084                 if(h->ref_count[list]>0){
6085                     for(i=0; i<2; i++){
6086                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
6087                             const int ref= h->ref_count[list] > 1 ? decode_cabac_mb_ref( h, list, 4*i ) : 0;
6088                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, ref, 1);
6089                         }else
6090                             fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, (LIST_NOT_USED&0xFF), 1);
6091                     }
6092                 }
6093             }
6094             for(list=0; list<2; list++){
6095                 for(i=0; i<2; i++){
6096                     if(IS_DIR(mb_type, i, list)){
6097                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mpx, &mpy);
6098                         mx = mpx + decode_cabac_mb_mvd( h, list, 4*i, 0 );
6099                         my = mpy + decode_cabac_mb_mvd( h, list, 4*i, 1 );
6100
6101                         tprintf("final mv:%d %d\n", mx, my);
6102                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx-mpx,my-mpy), 4);
6103                         fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, pack16to32(mx,my), 4);
6104                     }else{
6105                         fill_rectangle(h->mvd_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
6106                         fill_rectangle(h-> mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, 0, 4);
6107                     }
6108                 }
6109             }
6110         }
6111     }
6112
6113    if( IS_INTER( mb_type ) ) {
6114         h->chroma_pred_mode_table[mb_xy] = 0;
6115         write_back_motion( h, mb_type );
6116    }
6117
6118     if( !IS_INTRA16x16( mb_type ) ) {
6119         cbp  = decode_cabac_mb_cbp_luma( h );
6120         cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
6121     }
6122
6123     h->cbp_table[mb_xy] = cbp;
6124
6125     if( dct8x8_allowed && (cbp&15) && !IS_INTRA( mb_type ) ) {
6126         if( decode_cabac_mb_transform_size( h ) )
6127             mb_type |= MB_TYPE_8x8DCT;
6128     }
6129     s->current_picture.mb_type[mb_xy]= mb_type;
6130
6131     if( cbp || IS_INTRA16x16( mb_type ) ) {
6132         const uint8_t *scan, *dc_scan;
6133         int dqp;
6134
6135         if(IS_INTERLACED(mb_type)){
6136             scan= s->qscale ? h->field_scan : h->field_scan_q0;
6137             dc_scan= luma_dc_field_scan;
6138         }else{
6139             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
6140             dc_scan= luma_dc_zigzag_scan;
6141         }
6142
6143         h->last_qscale_diff = dqp = decode_cabac_mb_dqp( h );
6144         if( dqp == INT_MIN ){
6145             av_log(h->s.avctx, AV_LOG_ERROR, "cabac decode of qscale diff failed at %d %d\n", s->mb_x, s->mb_y);
6146             return -1;
6147         }
6148         s->qscale += dqp;
6149         if(((unsigned)s->qscale) > 51){
6150             if(s->qscale<0) s->qscale+= 52;
6151             else            s->qscale-= 52;
6152         }
6153         h->chroma_qp = get_chroma_qp(h->pps.chroma_qp_index_offset, s->qscale);
6154
6155         if( IS_INTRA16x16( mb_type ) ) {
6156             int i;
6157             //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 DC\n" );
6158             if( decode_cabac_residual( h, h->mb, 0, 0, dc_scan, NULL, 16) < 0)
6159                 return -1;
6160             if( cbp&15 ) {
6161                 for( i = 0; i < 16; i++ ) {
6162                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA16x16 AC:%d\n", i );
6163                     if( decode_cabac_residual(h, h->mb + 16*i, 1, i, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 )
6164                         return -1;
6165                 }
6166             } else {
6167                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
6168             }
6169         } else {
6170             int i8x8, i4x4;
6171             for( i8x8 = 0; i8x8 < 4; i8x8++ ) {
6172                 if( cbp & (1<<i8x8) ) {
6173                     if( IS_8x8DCT(mb_type) ) {
6174                         if( decode_cabac_residual(h, h->mb + 64*i8x8, 5, 4*i8x8,
6175                                 zigzag_scan8x8, h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 64) < 0 )
6176                             return -1;
6177                     } else
6178                     for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
6179                         const int index = 4*i8x8 + i4x4;
6180                         //av_log( s->avctx, AV_LOG_ERROR, "Luma4x4: %d\n", index );
6181                         if( decode_cabac_residual(h, h->mb + 16*index, 2, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) < 0 )
6182                             return -1;
6183                     }
6184                 } else {
6185                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
6186                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
6187                 }
6188             }
6189         }
6190
6191         if( cbp&0x30 ){
6192             int c;
6193             for( c = 0; c < 2; c++ ) {
6194                 //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
6195                 if( decode_cabac_residual(h, h->mb + 256 + 16*4*c, 3, c, chroma_dc_scan, NULL, 4) < 0)
6196                     return -1;
6197             }
6198         }
6199
6200         if( cbp&0x20 ) {
6201             int c, i;
6202             for( c = 0; c < 2; c++ ) {
6203                 for( i = 0; i < 4; i++ ) {
6204                     const int index = 16 + 4 * c + i;
6205                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
6206                     if( decode_cabac_residual(h, h->mb + 16*index, 4, index - 16, scan + 1, h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp], 15) < 0)
6207                         return -1;
6208                 }
6209             }
6210         } else {
6211             uint8_t * const nnz= &h->non_zero_count_cache[0];
6212             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
6213             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
6214         }
6215     } else {
6216         uint8_t * const nnz= &h->non_zero_count_cache[0];
6217         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
6218         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
6219         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
6220     }
6221
6222     s->current_picture.qscale_table[mb_xy]= s->qscale;
6223     write_back_non_zero_count(h);
6224
6225     return 0;
6226 }
6227
6228
6229 static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
6230     int i, d;
6231     const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
6232     const int alpha = alpha_table[index_a];
6233     const int beta  = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
6234
6235     if( bS[0] < 4 ) {
6236         int8_t tc[4];
6237         for(i=0; i<4; i++)
6238             tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
6239         h->s.dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
6240     } else {
6241         /* 16px edge length, because bS=4 is triggered by being at
6242          * the edge of an intra MB, so all 4 bS are the same */
6243             for( d = 0; d < 16; d++ ) {
6244                 const int p0 = pix[-1];
6245                 const int p1 = pix[-2];
6246                 const int p2 = pix[-3];
6247
6248                 const int q0 = pix[0];
6249                 const int q1 = pix[1];
6250                 const int q2 = pix[2];
6251
6252                 if( ABS( p0 - q0 ) < alpha &&
6253                     ABS( p1 - p0 ) < beta &&
6254                     ABS( q1 - q0 ) < beta ) {
6255
6256                     if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6257                         if( ABS( p2 - p0 ) < beta)
6258                         {
6259                             const int p3 = pix[-4];
6260                             /* p0', p1', p2' */
6261                             pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6262                             pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6263                             pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6264                         } else {
6265                             /* p0' */
6266                             pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6267                         }
6268                         if( ABS( q2 - q0 ) < beta)
6269                         {
6270                             const int q3 = pix[3];
6271                             /* q0', q1', q2' */
6272                             pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6273                             pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6274                             pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6275                         } else {
6276                             /* q0' */
6277                             pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6278                         }
6279                     }else{
6280                         /* p0', q0' */
6281                         pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6282                         pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6283                     }
6284                     tprintf("filter_mb_edgev i:%d d:%d\n# bS:4 -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, p2, p1, p0, q0, q1, q2, pix[-2], pix[-1], pix[0], pix[1]);
6285                 }
6286                 pix += stride;
6287             }
6288     }
6289 }
6290 static void filter_mb_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
6291     int i;
6292     const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
6293     const int alpha = alpha_table[index_a];
6294     const int beta  = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
6295
6296     if( bS[0] < 4 ) {
6297         int8_t tc[4];
6298         for(i=0; i<4; i++)
6299             tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
6300         h->s.dsp.h264_h_loop_filter_chroma(pix, stride, alpha, beta, tc);
6301     } else {
6302         h->s.dsp.h264_h_loop_filter_chroma_intra(pix, stride, alpha, beta);
6303     }
6304 }
6305
6306 static void filter_mb_mbaff_edgev( H264Context *h, uint8_t *pix, int stride, int bS[8], int qp[2] ) {
6307     int i;
6308     for( i = 0; i < 16; i++, pix += stride) {
6309         int index_a;
6310         int alpha;
6311         int beta;
6312
6313         int qp_index;
6314         int bS_index = (i >> 1);
6315         if (h->mb_field_decoding_flag) {
6316             bS_index &= ~1;
6317             bS_index |= (i & 1);
6318         }
6319
6320         if( bS[bS_index] == 0 ) {
6321             continue;
6322         }
6323
6324         qp_index = h->mb_field_decoding_flag ? (i & 1) : (i >> 3);
6325         index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
6326         alpha = alpha_table[index_a];
6327         beta  = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
6328
6329
6330         if( bS[bS_index] < 4 ) {
6331             const int tc0 = tc0_table[index_a][bS[bS_index] - 1];
6332             /* 4px edge length */
6333             const int p0 = pix[-1];
6334             const int p1 = pix[-2];
6335             const int p2 = pix[-3];
6336             const int q0 = pix[0];
6337             const int q1 = pix[1];
6338             const int q2 = pix[2];
6339
6340             if( ABS( p0 - q0 ) < alpha &&
6341                 ABS( p1 - p0 ) < beta &&
6342                 ABS( q1 - q0 ) < beta ) {
6343                 int tc = tc0;
6344                 int i_delta;
6345
6346                 if( ABS( p2 - p0 ) < beta ) {
6347                     pix[-2] = p1 + clip( ( p2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( p1 << 1 ) ) >> 1, -tc0, tc0 );
6348                     tc++;
6349                 }
6350                 if( ABS( q2 - q0 ) < beta ) {
6351                     pix[1] = q1 + clip( ( q2 + ( ( p0 + q0 + 1 ) >> 1 ) - ( q1 << 1 ) ) >> 1, -tc0, tc0 );
6352                     tc++;
6353                 }
6354
6355                 i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
6356                 pix[-1] = clip_uint8( p0 + i_delta );    /* p0' */
6357                 pix[0]  = clip_uint8( q0 - i_delta );    /* q0' */
6358                 tprintf("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);
6359             }
6360         }else{
6361             /* 4px edge length */
6362             const int p0 = pix[-1];
6363             const int p1 = pix[-2];
6364             const int p2 = pix[-3];
6365
6366             const int q0 = pix[0];
6367             const int q1 = pix[1];
6368             const int q2 = pix[2];
6369
6370             if( ABS( p0 - q0 ) < alpha &&
6371                 ABS( p1 - p0 ) < beta &&
6372                 ABS( q1 - q0 ) < beta ) {
6373
6374                 if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6375                     if( ABS( p2 - p0 ) < beta)
6376                     {
6377                         const int p3 = pix[-4];
6378                         /* p0', p1', p2' */
6379                         pix[-1] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6380                         pix[-2] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6381                         pix[-3] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6382                     } else {
6383                         /* p0' */
6384                         pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6385                     }
6386                     if( ABS( q2 - q0 ) < beta)
6387                     {
6388                         const int q3 = pix[3];
6389                         /* q0', q1', q2' */
6390                         pix[0] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6391                         pix[1] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6392                         pix[2] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6393                     } else {
6394                         /* q0' */
6395                         pix[0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6396                     }
6397                 }else{
6398                     /* p0', q0' */
6399                     pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6400                     pix[ 0] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6401                 }
6402                 tprintf("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]);
6403             }
6404         }
6405     }
6406 }
6407 static void filter_mb_mbaff_edgecv( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp[2] ) {
6408     int i;
6409     for( i = 0; i < 8; i++, pix += stride) {
6410         int index_a;
6411         int alpha;
6412         int beta;
6413
6414         int qp_index;
6415         int bS_index = i;
6416
6417         if( bS[bS_index] == 0 ) {
6418             continue;
6419         }
6420
6421         qp_index = h->mb_field_decoding_flag ? (i & 1) : (i >> 3);
6422         index_a = clip( qp[qp_index] + h->slice_alpha_c0_offset, 0, 51 );
6423         alpha = alpha_table[index_a];
6424         beta  = beta_table[clip( qp[qp_index] + h->slice_beta_offset, 0, 51 )];
6425         if( bS[bS_index] < 4 ) {
6426             const int tc = tc0_table[index_a][bS[bS_index] - 1] + 1;
6427             /* 2px edge length (because we use same bS than the one for luma) */
6428             const int p0 = pix[-1];
6429             const int p1 = pix[-2];
6430             const int q0 = pix[0];
6431             const int q1 = pix[1];
6432
6433             if( ABS( p0 - q0 ) < alpha &&
6434                 ABS( p1 - p0 ) < beta &&
6435                 ABS( q1 - q0 ) < beta ) {
6436                 const int i_delta = clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
6437
6438                 pix[-1] = clip_uint8( p0 + i_delta );    /* p0' */
6439                 pix[0]  = clip_uint8( q0 - i_delta );    /* q0' */
6440                 tprintf("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);
6441             }
6442         }else{
6443             const int p0 = pix[-1];
6444             const int p1 = pix[-2];
6445             const int q0 = pix[0];
6446             const int q1 = pix[1];
6447
6448             if( ABS( p0 - q0 ) < alpha &&
6449                 ABS( p1 - p0 ) < beta &&
6450                 ABS( q1 - q0 ) < beta ) {
6451
6452                 pix[-1] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
6453                 pix[0]  = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
6454                 tprintf("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]);
6455             }
6456         }
6457     }
6458 }
6459
6460 static void filter_mb_edgeh( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
6461     int i, d;
6462     const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
6463     const int alpha = alpha_table[index_a];
6464     const int beta  = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
6465     const int pix_next  = stride;
6466
6467     if( bS[0] < 4 ) {
6468         int8_t tc[4];
6469         for(i=0; i<4; i++)
6470             tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] : -1;
6471         h->s.dsp.h264_v_loop_filter_luma(pix, stride, alpha, beta, tc);
6472     } else {
6473         /* 16px edge length, see filter_mb_edgev */
6474             for( d = 0; d < 16; d++ ) {
6475                 const int p0 = pix[-1*pix_next];
6476                 const int p1 = pix[-2*pix_next];
6477                 const int p2 = pix[-3*pix_next];
6478                 const int q0 = pix[0];
6479                 const int q1 = pix[1*pix_next];
6480                 const int q2 = pix[2*pix_next];
6481
6482                 if( ABS( p0 - q0 ) < alpha &&
6483                     ABS( p1 - p0 ) < beta &&
6484                     ABS( q1 - q0 ) < beta ) {
6485
6486                     const int p3 = pix[-4*pix_next];
6487                     const int q3 = pix[ 3*pix_next];
6488
6489                     if(ABS( p0 - q0 ) < (( alpha >> 2 ) + 2 )){
6490                         if( ABS( p2 - p0 ) < beta) {
6491                             /* p0', p1', p2' */
6492                             pix[-1*pix_next] = ( p2 + 2*p1 + 2*p0 + 2*q0 + q1 + 4 ) >> 3;
6493                             pix[-2*pix_next] = ( p2 + p1 + p0 + q0 + 2 ) >> 2;
6494                             pix[-3*pix_next] = ( 2*p3 + 3*p2 + p1 + p0 + q0 + 4 ) >> 3;
6495                         } else {
6496                             /* p0' */
6497                             pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6498                         }
6499                         if( ABS( q2 - q0 ) < beta) {
6500                             /* q0', q1', q2' */
6501                             pix[0*pix_next] = ( p1 + 2*p0 + 2*q0 + 2*q1 + q2 + 4 ) >> 3;
6502                             pix[1*pix_next] = ( p0 + q0 + q1 + q2 + 2 ) >> 2;
6503                             pix[2*pix_next] = ( 2*q3 + 3*q2 + q1 + q0 + p0 + 4 ) >> 3;
6504                         } else {
6505                             /* q0' */
6506                             pix[0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6507                         }
6508                     }else{
6509                         /* p0', q0' */
6510                         pix[-1*pix_next] = ( 2*p1 + p0 + q1 + 2 ) >> 2;
6511                         pix[ 0*pix_next] = ( 2*q1 + q0 + p1 + 2 ) >> 2;
6512                     }
6513                     tprintf("filter_mb_edgeh i:%d d:%d, qp:%d, indexA:%d, alpha:%d, beta:%d\n# bS:%d -> [%02x, %02x, %02x, %02x, %02x, %02x] =>[%02x, %02x, %02x, %02x]\n", i, d, qp, index_a, alpha, beta, bS[i], p2, p1, p0, q0, q1, q2, pix[-2*pix_next], pix[-pix_next], pix[0], pix[pix_next]);
6514                 }
6515                 pix++;
6516             }
6517     }
6518 }
6519
6520 static void filter_mb_edgech( H264Context *h, uint8_t *pix, int stride, int bS[4], int qp ) {
6521     int i;
6522     const int index_a = clip( qp + h->slice_alpha_c0_offset, 0, 51 );
6523     const int alpha = alpha_table[index_a];
6524     const int beta  = beta_table[clip( qp + h->slice_beta_offset, 0, 51 )];
6525
6526     if( bS[0] < 4 ) {
6527         int8_t tc[4];
6528         for(i=0; i<4; i++)
6529             tc[i] = bS[i] ? tc0_table[index_a][bS[i] - 1] + 1 : 0;
6530         h->s.dsp.h264_v_loop_filter_chroma(pix, stride, alpha, beta, tc);
6531     } else {
6532         h->s.dsp.h264_v_loop_filter_chroma_intra(pix, stride, alpha, beta);
6533     }
6534 }
6535
6536 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) {
6537     MpegEncContext * const s = &h->s;
6538     const int mb_xy= mb_x + mb_y*s->mb_stride;
6539     int first_vertical_edge_done = 0;
6540     int dir;
6541     /* FIXME: A given frame may occupy more than one position in
6542      * the reference list. So ref2frm should be populated with
6543      * frame numbers, not indices. */
6544     static const int ref2frm[18] = {-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
6545
6546     if (h->mb_aff_frame
6547             // left mb is in picture
6548             && h->slice_table[mb_xy-1] != 255
6549             // and current and left pair do not have the same interlaced type
6550             && (IS_INTERLACED(s->current_picture.mb_type[mb_xy]) != IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]))
6551             // and left mb is in the same slice if deblocking_filter == 2
6552             && (h->deblocking_filter!=2 || h->slice_table[mb_xy-1] == h->slice_table[mb_xy])) {
6553         /* First vertical edge is different in MBAFF frames
6554          * There are 8 different bS to compute and 2 different Qp
6555          */
6556         int bS[8];
6557         int qp[2];
6558         int chroma_qp[2];
6559
6560         int i;
6561         first_vertical_edge_done = 1;
6562         for( i = 0; i < 8; i++ ) {
6563             int y = i>>1;
6564             int b_idx= 8 + 4 + 8*y;
6565             int bn_idx= b_idx - 1;
6566
6567             int mbn_xy = h->mb_field_decoding_flag ? h->left_mb_xy[i>>2] : h->left_mb_xy[i&1];
6568
6569             if( IS_INTRA( s->current_picture.mb_type[mb_xy] ) ||
6570                 IS_INTRA( s->current_picture.mb_type[mbn_xy] ) ) {
6571                 bS[i] = 4;
6572             } else if( h->non_zero_count_cache[b_idx] != 0 ||
6573                 /* FIXME: with 8x8dct + cavlc, should check cbp instead of nnz */
6574                 h->non_zero_count_cache[bn_idx] != 0 ) {
6575                 bS[i] = 2;
6576             } else {
6577                 int l;
6578                 bS[i] = 0;
6579                 for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
6580                     if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
6581                         ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6582                         ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4 ) {
6583                         bS[i] = 1;
6584                         break;
6585                     }
6586                 }
6587             }
6588         }
6589         if(bS[0]+bS[1]+bS[2]+bS[3] != 0) {
6590             // Do not use s->qscale as luma quantizer because it has not the same
6591             // value in IPCM macroblocks.
6592             qp[0] = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[h->left_mb_xy[0]] + 1 ) >> 1;
6593             chroma_qp[0] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy] ) +
6594                              get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[h->left_mb_xy[0]] ) + 1 ) >> 1;
6595             qp[1] = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[h->left_mb_xy[1]] + 1 ) >> 1;
6596             chroma_qp[1] = ( get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mb_xy] ) +
6597                              get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[h->left_mb_xy[1]] ) + 1 ) >> 1;
6598
6599             /* Filter edge */
6600             tprintf("filter mb:%d/%d MBAFF, QPy:%d/%d, QPc:%d/%d ls:%d uvls:%d", mb_x, mb_y, qp[0], qp[1], chroma_qp[0], chroma_qp[1], linesize, uvlinesize);
6601             { int i; for (i = 0; i < 8; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
6602             filter_mb_mbaff_edgev ( h, &img_y [0], linesize,   bS, qp );
6603             filter_mb_mbaff_edgecv( h, &img_cb[0], uvlinesize, bS, chroma_qp );
6604             filter_mb_mbaff_edgecv( h, &img_cr[0], uvlinesize, bS, chroma_qp );
6605         }
6606     }
6607     /* dir : 0 -> vertical edge, 1 -> horizontal edge */
6608     for( dir = 0; dir < 2; dir++ )
6609     {
6610         int edge;
6611         const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy;
6612         const int mb_type = s->current_picture.mb_type[mb_xy];
6613         const int mbm_type = s->current_picture.mb_type[mbm_xy];
6614         int start = h->slice_table[mbm_xy] == 255 ? 1 : 0;
6615
6616         const int edges = ((mb_type & mbm_type) & (MB_TYPE_16x16|MB_TYPE_SKIP))
6617                                                == (MB_TYPE_16x16|MB_TYPE_SKIP) ? 1 : 4;
6618         // how often to recheck mv-based bS when iterating between edges
6619         const int mask_edge = (mb_type & (MB_TYPE_16x16 | (MB_TYPE_16x8 << dir))) ? 3 :
6620                               (mb_type & (MB_TYPE_8x16 >> dir)) ? 1 : 0;
6621         // how often to recheck mv-based bS when iterating along each edge
6622         const int mask_par0 = mb_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir));
6623
6624         if (first_vertical_edge_done) {
6625             start = 1;
6626             first_vertical_edge_done = 0;
6627         }
6628
6629         if (h->deblocking_filter==2 && h->slice_table[mbm_xy] != h->slice_table[mb_xy])
6630             start = 1;
6631
6632         /* Calculate bS */
6633         for( edge = start; edge < edges; edge++ ) {
6634             /* mbn_xy: neighbor macroblock */
6635             const int mbn_xy = edge > 0 ? mb_xy : mbm_xy;
6636             const int mbn_type = s->current_picture.mb_type[mbn_xy];
6637             int bS[4];
6638             int qp;
6639
6640             if( (edge&1) && IS_8x8DCT(mb_type) )
6641                 continue;
6642
6643             if (h->mb_aff_frame && (dir == 1) && (edge == 0) && ((mb_y & 1) == 0)
6644                 && !IS_INTERLACED(mb_type)
6645                 && IS_INTERLACED(mbn_type)
6646                 ) {
6647                 // This is a special case in the norm where the filtering must
6648                 // be done twice (one each of the field) even if we are in a
6649                 // frame macroblock.
6650                 //
6651                 unsigned int tmp_linesize   = 2 *   linesize;
6652                 unsigned int tmp_uvlinesize = 2 * uvlinesize;
6653                 int mbn_xy = mb_xy - 2 * s->mb_stride;
6654                 int qp, chroma_qp;
6655
6656                 // first filtering
6657                 if( IS_INTRA(mb_type) ||
6658                     IS_INTRA(s->current_picture.mb_type[mbn_xy]) ) {
6659                     bS[0] = bS[1] = bS[2] = bS[3] = 3;
6660                 } else {
6661                     // TODO
6662                     av_log(h->s.avctx, AV_LOG_ERROR, "both non intra (TODO)\n");
6663                 }
6664                 /* Filter edge */
6665                 // Do not use s->qscale as luma quantizer because it has not the same
6666                 // value in IPCM macroblocks.
6667                 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6668                 tprintf("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);
6669                 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
6670                 filter_mb_edgeh( h, &img_y[0], tmp_linesize, bS, qp );
6671                 chroma_qp = ( h->chroma_qp +
6672                               get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
6673                 filter_mb_edgech( h, &img_cb[0], tmp_uvlinesize, bS, chroma_qp );
6674                 filter_mb_edgech( h, &img_cr[0], tmp_uvlinesize, bS, chroma_qp );
6675
6676                 // second filtering
6677                 mbn_xy += s->mb_stride;
6678                 if( IS_INTRA(mb_type) ||
6679                     IS_INTRA(mbn_type) ) {
6680                     bS[0] = bS[1] = bS[2] = bS[3] = 3;
6681                 } else {
6682                     // TODO
6683                     av_log(h->s.avctx, AV_LOG_ERROR, "both non intra (TODO)\n");
6684                 }
6685                 /* Filter edge */
6686                 // Do not use s->qscale as luma quantizer because it has not the same
6687                 // value in IPCM macroblocks.
6688                 qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6689                 tprintf("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);
6690                 { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
6691                 filter_mb_edgeh( h, &img_y[linesize], tmp_linesize, bS, qp );
6692                 chroma_qp = ( h->chroma_qp +
6693                               get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
6694                 filter_mb_edgech( h, &img_cb[uvlinesize], tmp_uvlinesize, bS, chroma_qp );
6695                 filter_mb_edgech( h, &img_cr[uvlinesize], tmp_uvlinesize, bS, chroma_qp );
6696                 continue;
6697             }
6698             if( IS_INTRA(mb_type) ||
6699                 IS_INTRA(mbn_type) ) {
6700                 int value;
6701                 if (edge == 0) {
6702                     if (   (!IS_INTERLACED(mb_type) && !IS_INTERLACED(mbm_type))
6703                         || ((h->mb_aff_frame || (s->picture_structure != PICT_FRAME)) && (dir == 0))
6704                     ) {
6705                         value = 4;
6706                     } else {
6707                         value = 3;
6708                     }
6709                 } else {
6710                     value = 3;
6711                 }
6712                 bS[0] = bS[1] = bS[2] = bS[3] = value;
6713             } else {
6714                 int i, l;
6715                 int mv_done;
6716
6717                 if( edge & mask_edge ) {
6718                     bS[0] = bS[1] = bS[2] = bS[3] = 0;
6719                     mv_done = 1;
6720                 }
6721                 else if( mask_par0 && (edge || (mbn_type & (MB_TYPE_16x16 | (MB_TYPE_8x16 >> dir)))) ) {
6722                     int b_idx= 8 + 4 + edge * (dir ? 8:1);
6723                     int bn_idx= b_idx - (dir ? 8:1);
6724                     int v = 0;
6725                     for( l = 0; !v && l < 1 + (h->slice_type == B_TYPE); l++ ) {
6726                         v |= ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
6727                              ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6728                              ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4;
6729                     }
6730                     bS[0] = bS[1] = bS[2] = bS[3] = v;
6731                     mv_done = 1;
6732                 }
6733                 else
6734                     mv_done = 0;
6735
6736                 for( i = 0; i < 4; i++ ) {
6737                     int x = dir == 0 ? edge : i;
6738                     int y = dir == 0 ? i    : edge;
6739                     int b_idx= 8 + 4 + x + 8*y;
6740                     int bn_idx= b_idx - (dir ? 8:1);
6741
6742                     if( h->non_zero_count_cache[b_idx] != 0 ||
6743                         h->non_zero_count_cache[bn_idx] != 0 ) {
6744                         bS[i] = 2;
6745                     }
6746                     else if(!mv_done)
6747                     {
6748                         bS[i] = 0;
6749                         for( l = 0; l < 1 + (h->slice_type == B_TYPE); l++ ) {
6750                             if( ref2frm[h->ref_cache[l][b_idx]+2] != ref2frm[h->ref_cache[l][bn_idx]+2] ||
6751                                 ABS( h->mv_cache[l][b_idx][0] - h->mv_cache[l][bn_idx][0] ) >= 4 ||
6752                                 ABS( h->mv_cache[l][b_idx][1] - h->mv_cache[l][bn_idx][1] ) >= 4 ) {
6753                                 bS[i] = 1;
6754                                 break;
6755                             }
6756                         }
6757                     }
6758                 }
6759
6760                 if(bS[0]+bS[1]+bS[2]+bS[3] == 0)
6761                     continue;
6762             }
6763
6764             /* Filter edge */
6765             // Do not use s->qscale as luma quantizer because it has not the same
6766             // value in IPCM macroblocks.
6767             qp = ( s->current_picture.qscale_table[mb_xy] + s->current_picture.qscale_table[mbn_xy] + 1 ) >> 1;
6768             //tprintf("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]);
6769             tprintf("filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
6770             { int i; for (i = 0; i < 4; i++) tprintf(" bS[%d]:%d", i, bS[i]); tprintf("\n"); }
6771             if( dir == 0 ) {
6772                 filter_mb_edgev( h, &img_y[4*edge], linesize, bS, qp );
6773                 if( (edge&1) == 0 ) {
6774                     int chroma_qp = ( h->chroma_qp +
6775                                       get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
6776                     filter_mb_edgecv( h, &img_cb[2*edge], uvlinesize, bS, chroma_qp );
6777                     filter_mb_edgecv( h, &img_cr[2*edge], uvlinesize, bS, chroma_qp );
6778                 }
6779             } else {
6780                 filter_mb_edgeh( h, &img_y[4*edge*linesize], linesize, bS, qp );
6781                 if( (edge&1) == 0 ) {
6782                     int chroma_qp = ( h->chroma_qp +
6783                                       get_chroma_qp( h->pps.chroma_qp_index_offset, s->current_picture.qscale_table[mbn_xy] ) + 1 ) >> 1;
6784                     filter_mb_edgech( h, &img_cb[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
6785                     filter_mb_edgech( h, &img_cr[2*edge*uvlinesize], uvlinesize, bS, chroma_qp );
6786                 }
6787             }
6788         }
6789     }
6790 }
6791
6792 static int decode_slice(H264Context *h){
6793     MpegEncContext * const s = &h->s;
6794     const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
6795
6796     s->mb_skip_run= -1;
6797
6798     if( h->pps.cabac ) {
6799         int i;
6800
6801         /* realign */
6802         align_get_bits( &s->gb );
6803
6804         /* init cabac */
6805         ff_init_cabac_states( &h->cabac, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64 );
6806         ff_init_cabac_decoder( &h->cabac,
6807                                s->gb.buffer + get_bits_count(&s->gb)/8,
6808                                ( s->gb.size_in_bits - get_bits_count(&s->gb) + 7)/8);
6809         /* calculate pre-state */
6810         for( i= 0; i < 460; i++ ) {
6811             int pre;
6812             if( h->slice_type == I_TYPE )
6813                 pre = clip( ((cabac_context_init_I[i][0] * s->qscale) >>4 ) + cabac_context_init_I[i][1], 1, 126 );
6814             else
6815                 pre = 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 );
6816
6817             if( pre <= 63 )
6818                 h->cabac_state[i] = 2 * ( 63 - pre ) + 0;
6819             else
6820                 h->cabac_state[i] = 2 * ( pre - 64 ) + 1;
6821         }
6822
6823         for(;;){
6824             int ret = decode_mb_cabac(h);
6825             int eos;
6826
6827             if(ret>=0) hl_decode_mb(h);
6828
6829             /* XXX: useless as decode_mb_cabac it doesn't support that ... */
6830             if( ret >= 0 && h->mb_aff_frame ) { //FIXME optimal? or let mb_decode decode 16x32 ?
6831                 s->mb_y++;
6832
6833                 if(ret>=0) ret = decode_mb_cabac(h);
6834
6835                 if(ret>=0) hl_decode_mb(h);
6836                 s->mb_y--;
6837             }
6838             eos = get_cabac_terminate( &h->cabac );
6839
6840             if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 1) {
6841                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
6842                 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);
6843                 return -1;
6844             }
6845
6846             if( ++s->mb_x >= s->mb_width ) {
6847                 s->mb_x = 0;
6848                 ff_draw_horiz_band(s, 16*s->mb_y, 16);
6849                 ++s->mb_y;
6850                 if(h->mb_aff_frame) {
6851                     ++s->mb_y;
6852                 }
6853             }
6854
6855             if( eos || s->mb_y >= s->mb_height ) {
6856                 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6857                 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);
6858                 return 0;
6859             }
6860         }
6861
6862     } else {
6863         for(;;){
6864             int ret = decode_mb_cavlc(h);
6865
6866             if(ret>=0) hl_decode_mb(h);
6867
6868             if(ret>=0 && h->mb_aff_frame){ //FIXME optimal? or let mb_decode decode 16x32 ?
6869                 s->mb_y++;
6870                 ret = decode_mb_cavlc(h);
6871
6872                 if(ret>=0) hl_decode_mb(h);
6873                 s->mb_y--;
6874             }
6875
6876             if(ret<0){
6877                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
6878                 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);
6879
6880                 return -1;
6881             }
6882
6883             if(++s->mb_x >= s->mb_width){
6884                 s->mb_x=0;
6885                 ff_draw_horiz_band(s, 16*s->mb_y, 16);
6886                 ++s->mb_y;
6887                 if(h->mb_aff_frame) {
6888                     ++s->mb_y;
6889                 }
6890                 if(s->mb_y >= s->mb_height){
6891                     tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6892
6893                     if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
6894                         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);
6895
6896                         return 0;
6897                     }else{
6898                         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);
6899
6900                         return -1;
6901                     }
6902                 }
6903             }
6904
6905             if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
6906                 tprintf("slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
6907                 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
6908                     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);
6909
6910                     return 0;
6911                 }else{
6912                     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);
6913
6914                     return -1;
6915                 }
6916             }
6917         }
6918     }
6919
6920 #if 0
6921     for(;s->mb_y < s->mb_height; s->mb_y++){
6922         for(;s->mb_x < s->mb_width; s->mb_x++){
6923             int ret= decode_mb(h);
6924
6925             hl_decode_mb(h);
6926
6927             if(ret<0){
6928                 fprintf(stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
6929                 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);
6930
6931                 return -1;
6932             }
6933
6934             if(++s->mb_x >= s->mb_width){
6935                 s->mb_x=0;
6936                 if(++s->mb_y >= s->mb_height){
6937                     if(get_bits_count(s->gb) == s->gb.size_in_bits){
6938                         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);
6939
6940                         return 0;
6941                     }else{
6942                         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);
6943
6944                         return -1;
6945                     }
6946                 }
6947             }
6948
6949             if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
6950                 if(get_bits_count(s->gb) == s->gb.size_in_bits){
6951                     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);
6952
6953                     return 0;
6954                 }else{
6955                     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);
6956
6957                     return -1;
6958                 }
6959             }
6960         }
6961         s->mb_x=0;
6962         ff_draw_horiz_band(s, 16*s->mb_y, 16);
6963     }
6964 #endif
6965     return -1; //not reached
6966 }
6967
6968 static int decode_unregistered_user_data(H264Context *h, int size){
6969     MpegEncContext * const s = &h->s;
6970     uint8_t user_data[16+256];
6971     int e, build, i;
6972
6973     if(size<16)
6974         return -1;
6975
6976     for(i=0; i<sizeof(user_data)-1 && i<size; i++){
6977         user_data[i]= get_bits(&s->gb, 8);
6978     }
6979
6980     user_data[i]= 0;
6981     e= sscanf(user_data+16, "x264 - core %d"/*%s - H.264/MPEG-4 AVC codec - Copyleft 2005 - http://www.videolan.org/x264.html*/, &build);
6982     if(e==1 && build>=0)
6983         h->x264_build= build;
6984
6985     if(s->avctx->debug & FF_DEBUG_BUGS)
6986         av_log(s->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data+16);
6987
6988     for(; i<size; i++)
6989         skip_bits(&s->gb, 8);
6990
6991     return 0;
6992 }
6993
6994 static int decode_sei(H264Context *h){
6995     MpegEncContext * const s = &h->s;
6996
6997     while(get_bits_count(&s->gb) + 16 < s->gb.size_in_bits){
6998         int size, type;
6999
7000         type=0;
7001         do{
7002             type+= show_bits(&s->gb, 8);
7003         }while(get_bits(&s->gb, 8) == 255);
7004
7005         size=0;
7006         do{
7007             size+= show_bits(&s->gb, 8);
7008         }while(get_bits(&s->gb, 8) == 255);
7009
7010         switch(type){
7011         case 5:
7012             if(decode_unregistered_user_data(h, size) < 0);
7013                 return -1;
7014             break;
7015         default:
7016             skip_bits(&s->gb, 8*size);
7017         }
7018
7019         //FIXME check bits here
7020         align_get_bits(&s->gb);
7021     }
7022
7023     return 0;
7024 }
7025
7026 static inline void decode_hrd_parameters(H264Context *h, SPS *sps){
7027     MpegEncContext * const s = &h->s;
7028     int cpb_count, i;
7029     cpb_count = get_ue_golomb(&s->gb) + 1;
7030     get_bits(&s->gb, 4); /* bit_rate_scale */
7031     get_bits(&s->gb, 4); /* cpb_size_scale */
7032     for(i=0; i<cpb_count; i++){
7033         get_ue_golomb(&s->gb); /* bit_rate_value_minus1 */
7034         get_ue_golomb(&s->gb); /* cpb_size_value_minus1 */
7035         get_bits1(&s->gb);     /* cbr_flag */
7036     }
7037     get_bits(&s->gb, 5); /* initial_cpb_removal_delay_length_minus1 */
7038     get_bits(&s->gb, 5); /* cpb_removal_delay_length_minus1 */
7039     get_bits(&s->gb, 5); /* dpb_output_delay_length_minus1 */
7040     get_bits(&s->gb, 5); /* time_offset_length */
7041 }
7042
7043 static inline int decode_vui_parameters(H264Context *h, SPS *sps){
7044     MpegEncContext * const s = &h->s;
7045     int aspect_ratio_info_present_flag, aspect_ratio_idc;
7046     int nal_hrd_parameters_present_flag, vcl_hrd_parameters_present_flag;
7047
7048     aspect_ratio_info_present_flag= get_bits1(&s->gb);
7049
7050     if( aspect_ratio_info_present_flag ) {
7051         aspect_ratio_idc= get_bits(&s->gb, 8);
7052         if( aspect_ratio_idc == EXTENDED_SAR ) {
7053             sps->sar.num= get_bits(&s->gb, 16);
7054             sps->sar.den= get_bits(&s->gb, 16);
7055         }else if(aspect_ratio_idc < 16){
7056             sps->sar=  pixel_aspect[aspect_ratio_idc];
7057         }else{
7058             av_log(h->s.avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
7059             return -1;
7060         }
7061     }else{
7062         sps->sar.num=
7063         sps->sar.den= 0;
7064     }
7065 //            s->avctx->aspect_ratio= sar_width*s->width / (float)(s->height*sar_height);
7066
7067     if(get_bits1(&s->gb)){      /* overscan_info_present_flag */
7068         get_bits1(&s->gb);      /* overscan_appropriate_flag */
7069     }
7070
7071     if(get_bits1(&s->gb)){      /* video_signal_type_present_flag */
7072         get_bits(&s->gb, 3);    /* video_format */
7073         get_bits1(&s->gb);      /* video_full_range_flag */
7074         if(get_bits1(&s->gb)){  /* colour_description_present_flag */
7075             get_bits(&s->gb, 8); /* colour_primaries */
7076             get_bits(&s->gb, 8); /* transfer_characteristics */
7077             get_bits(&s->gb, 8); /* matrix_coefficients */
7078         }
7079     }
7080
7081     if(get_bits1(&s->gb)){      /* chroma_location_info_present_flag */
7082         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_top_field */
7083         get_ue_golomb(&s->gb);  /* chroma_sample_location_type_bottom_field */
7084     }
7085
7086     sps->timing_info_present_flag = get_bits1(&s->gb);
7087     if(sps->timing_info_present_flag){
7088         sps->num_units_in_tick = get_bits_long(&s->gb, 32);
7089         sps->time_scale = get_bits_long(&s->gb, 32);
7090         sps->fixed_frame_rate_flag = get_bits1(&s->gb);
7091     }
7092
7093     nal_hrd_parameters_present_flag = get_bits1(&s->gb);
7094     if(nal_hrd_parameters_present_flag)
7095         decode_hrd_parameters(h, sps);
7096     vcl_hrd_parameters_present_flag = get_bits1(&s->gb);
7097     if(vcl_hrd_parameters_present_flag)
7098         decode_hrd_parameters(h, sps);
7099     if(nal_hrd_parameters_present_flag || vcl_hrd_parameters_present_flag)
7100         get_bits1(&s->gb);     /* low_delay_hrd_flag */
7101     get_bits1(&s->gb);         /* pic_struct_present_flag */
7102
7103     sps->bitstream_restriction_flag = get_bits1(&s->gb);
7104     if(sps->bitstream_restriction_flag){
7105         get_bits1(&s->gb);     /* motion_vectors_over_pic_boundaries_flag */
7106         get_ue_golomb(&s->gb); /* max_bytes_per_pic_denom */
7107         get_ue_golomb(&s->gb); /* max_bits_per_mb_denom */
7108         get_ue_golomb(&s->gb); /* log2_max_mv_length_horizontal */
7109         get_ue_golomb(&s->gb); /* log2_max_mv_length_vertical */
7110         sps->num_reorder_frames = get_ue_golomb(&s->gb);
7111         get_ue_golomb(&s->gb); /* max_dec_frame_buffering */
7112     }
7113
7114     return 0;
7115 }
7116
7117 static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
7118                                 const uint8_t *jvt_list, const uint8_t *fallback_list){
7119     MpegEncContext * const s = &h->s;
7120     int i, last = 8, next = 8;
7121     const uint8_t *scan = size == 16 ? zigzag_scan : zigzag_scan8x8;
7122     if(!get_bits1(&s->gb)) /* matrix not written, we use the predicted one */
7123         memcpy(factors, fallback_list, size*sizeof(uint8_t));
7124     else
7125     for(i=0;i<size;i++){
7126         if(next)
7127             next = (last + get_se_golomb(&s->gb)) & 0xff;
7128         if(!i && !next){ /* matrix not written, we use the preset one */
7129             memcpy(factors, jvt_list, size*sizeof(uint8_t));
7130             break;
7131         }
7132         last = factors[scan[i]] = next ? next : last;
7133     }
7134 }
7135
7136 static void decode_scaling_matrices(H264Context *h, SPS *sps, PPS *pps, int is_sps,
7137                                    uint8_t (*scaling_matrix4)[16], uint8_t (*scaling_matrix8)[64]){
7138     MpegEncContext * const s = &h->s;
7139     int fallback_sps = !is_sps && sps->scaling_matrix_present;
7140     const uint8_t *fallback[4] = {
7141         fallback_sps ? sps->scaling_matrix4[0] : default_scaling4[0],
7142         fallback_sps ? sps->scaling_matrix4[3] : default_scaling4[1],
7143         fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
7144         fallback_sps ? sps->scaling_matrix8[1] : default_scaling8[1]
7145     };
7146     if(get_bits1(&s->gb)){
7147         sps->scaling_matrix_present |= is_sps;
7148         decode_scaling_list(h,scaling_matrix4[0],16,default_scaling4[0],fallback[0]); // Intra, Y
7149         decode_scaling_list(h,scaling_matrix4[1],16,default_scaling4[0],scaling_matrix4[0]); // Intra, Cr
7150         decode_scaling_list(h,scaling_matrix4[2],16,default_scaling4[0],scaling_matrix4[1]); // Intra, Cb
7151         decode_scaling_list(h,scaling_matrix4[3],16,default_scaling4[1],fallback[1]); // Inter, Y
7152         decode_scaling_list(h,scaling_matrix4[4],16,default_scaling4[1],scaling_matrix4[3]); // Inter, Cr
7153         decode_scaling_list(h,scaling_matrix4[5],16,default_scaling4[1],scaling_matrix4[4]); // Inter, Cb
7154         if(is_sps || pps->transform_8x8_mode){
7155             decode_scaling_list(h,scaling_matrix8[0],64,default_scaling8[0],fallback[2]);  // Intra, Y
7156             decode_scaling_list(h,scaling_matrix8[1],64,default_scaling8[1],fallback[3]);  // Inter, Y
7157         }
7158     } else if(fallback_sps) {
7159         memcpy(scaling_matrix4, sps->scaling_matrix4, 6*16*sizeof(uint8_t));
7160         memcpy(scaling_matrix8, sps->scaling_matrix8, 2*64*sizeof(uint8_t));
7161     }
7162 }
7163
7164 static inline int decode_seq_parameter_set(H264Context *h){
7165     MpegEncContext * const s = &h->s;
7166     int profile_idc, level_idc;
7167     int sps_id, i;
7168     SPS *sps;
7169
7170     profile_idc= get_bits(&s->gb, 8);
7171     get_bits1(&s->gb);   //constraint_set0_flag
7172     get_bits1(&s->gb);   //constraint_set1_flag
7173     get_bits1(&s->gb);   //constraint_set2_flag
7174     get_bits1(&s->gb);   //constraint_set3_flag
7175     get_bits(&s->gb, 4); // reserved
7176     level_idc= get_bits(&s->gb, 8);
7177     sps_id= get_ue_golomb(&s->gb);
7178
7179     sps= &h->sps_buffer[ sps_id ];
7180     sps->profile_idc= profile_idc;
7181     sps->level_idc= level_idc;
7182
7183     if(sps->profile_idc >= 100){ //high profile
7184         if(get_ue_golomb(&s->gb) == 3) //chroma_format_idc
7185             get_bits1(&s->gb);  //residual_color_transform_flag
7186         get_ue_golomb(&s->gb);  //bit_depth_luma_minus8
7187         get_ue_golomb(&s->gb);  //bit_depth_chroma_minus8
7188         sps->transform_bypass = get_bits1(&s->gb);
7189         decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
7190     }else
7191         sps->scaling_matrix_present = 0;
7192
7193     sps->log2_max_frame_num= get_ue_golomb(&s->gb) + 4;
7194     sps->poc_type= get_ue_golomb(&s->gb);
7195
7196     if(sps->poc_type == 0){ //FIXME #define
7197         sps->log2_max_poc_lsb= get_ue_golomb(&s->gb) + 4;
7198     } else if(sps->poc_type == 1){//FIXME #define
7199         sps->delta_pic_order_always_zero_flag= get_bits1(&s->gb);
7200         sps->offset_for_non_ref_pic= get_se_golomb(&s->gb);
7201         sps->offset_for_top_to_bottom_field= get_se_golomb(&s->gb);
7202         sps->poc_cycle_length= get_ue_golomb(&s->gb);
7203
7204         for(i=0; i<sps->poc_cycle_length; i++)
7205             sps->offset_for_ref_frame[i]= get_se_golomb(&s->gb);
7206     }
7207     if(sps->poc_type > 2){
7208         av_log(h->s.avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
7209         return -1;
7210     }
7211
7212     sps->ref_frame_count= get_ue_golomb(&s->gb);
7213     if(sps->ref_frame_count > MAX_PICTURE_COUNT-2){
7214         av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
7215     }
7216     sps->gaps_in_frame_num_allowed_flag= get_bits1(&s->gb);
7217     sps->mb_width= get_ue_golomb(&s->gb) + 1;
7218     sps->mb_height= get_ue_golomb(&s->gb) + 1;
7219     if((unsigned)sps->mb_width >= INT_MAX/16 || (unsigned)sps->mb_height >= INT_MAX/16 ||
7220        avcodec_check_dimensions(NULL, 16*sps->mb_width, 16*sps->mb_height))
7221         return -1;
7222
7223     sps->frame_mbs_only_flag= get_bits1(&s->gb);
7224     if(!sps->frame_mbs_only_flag)
7225         sps->mb_aff= get_bits1(&s->gb);
7226     else
7227         sps->mb_aff= 0;
7228
7229     sps->direct_8x8_inference_flag= get_bits1(&s->gb);
7230
7231     sps->crop= get_bits1(&s->gb);
7232     if(sps->crop){
7233         sps->crop_left  = get_ue_golomb(&s->gb);
7234         sps->crop_right = get_ue_golomb(&s->gb);
7235         sps->crop_top   = get_ue_golomb(&s->gb);
7236         sps->crop_bottom= get_ue_golomb(&s->gb);
7237         if(sps->crop_left || sps->crop_top){
7238             av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
7239         }
7240     }else{
7241         sps->crop_left  =
7242         sps->crop_right =
7243         sps->crop_top   =
7244         sps->crop_bottom= 0;
7245     }
7246
7247     sps->vui_parameters_present_flag= get_bits1(&s->gb);
7248     if( sps->vui_parameters_present_flag )
7249         decode_vui_parameters(h, sps);
7250
7251     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7252         av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%d profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s\n",
7253                sps_id, sps->profile_idc, sps->level_idc,
7254                sps->poc_type,
7255                sps->ref_frame_count,
7256                sps->mb_width, sps->mb_height,
7257                sps->frame_mbs_only_flag ? "FRM" : (sps->mb_aff ? "MB-AFF" : "PIC-AFF"),
7258                sps->direct_8x8_inference_flag ? "8B8" : "",
7259                sps->crop_left, sps->crop_right,
7260                sps->crop_top, sps->crop_bottom,
7261                sps->vui_parameters_present_flag ? "VUI" : ""
7262                );
7263     }
7264     return 0;
7265 }
7266
7267 static inline int decode_picture_parameter_set(H264Context *h, int bit_length){
7268     MpegEncContext * const s = &h->s;
7269     int pps_id= get_ue_golomb(&s->gb);
7270     PPS *pps= &h->pps_buffer[pps_id];
7271
7272     pps->sps_id= get_ue_golomb(&s->gb);
7273     pps->cabac= get_bits1(&s->gb);
7274     pps->pic_order_present= get_bits1(&s->gb);
7275     pps->slice_group_count= get_ue_golomb(&s->gb) + 1;
7276     if(pps->slice_group_count > 1 ){
7277         pps->mb_slice_group_map_type= get_ue_golomb(&s->gb);
7278         av_log(h->s.avctx, AV_LOG_ERROR, "FMO not supported\n");
7279         switch(pps->mb_slice_group_map_type){
7280         case 0:
7281 #if 0
7282 |   for( i = 0; i <= num_slice_groups_minus1; i++ ) |   |        |
7283 |    run_length[ i ]                                |1  |ue(v)   |
7284 #endif
7285             break;
7286         case 2:
7287 #if 0
7288 |   for( i = 0; i < num_slice_groups_minus1; i++ )  |   |        |
7289 |{                                                  |   |        |
7290 |    top_left_mb[ i ]                               |1  |ue(v)   |
7291 |    bottom_right_mb[ i ]                           |1  |ue(v)   |
7292 |   }                                               |   |        |
7293 #endif
7294             break;
7295         case 3:
7296         case 4:
7297         case 5:
7298 #if 0
7299 |   slice_group_change_direction_flag               |1  |u(1)    |
7300 |   slice_group_change_rate_minus1                  |1  |ue(v)   |
7301 #endif
7302             break;
7303         case 6:
7304 #if 0
7305 |   slice_group_id_cnt_minus1                       |1  |ue(v)   |
7306 |   for( i = 0; i <= slice_group_id_cnt_minus1; i++ |   |        |
7307 |)                                                  |   |        |
7308 |    slice_group_id[ i ]                            |1  |u(v)    |
7309 #endif
7310             break;
7311         }
7312     }
7313     pps->ref_count[0]= get_ue_golomb(&s->gb) + 1;
7314     pps->ref_count[1]= get_ue_golomb(&s->gb) + 1;
7315     if(pps->ref_count[0] > 32 || pps->ref_count[1] > 32){
7316         av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
7317         return -1;
7318     }
7319
7320     pps->weighted_pred= get_bits1(&s->gb);
7321     pps->weighted_bipred_idc= get_bits(&s->gb, 2);
7322     pps->init_qp= get_se_golomb(&s->gb) + 26;
7323     pps->init_qs= get_se_golomb(&s->gb) + 26;
7324     pps->chroma_qp_index_offset= get_se_golomb(&s->gb);
7325     pps->deblocking_filter_parameters_present= get_bits1(&s->gb);
7326     pps->constrained_intra_pred= get_bits1(&s->gb);
7327     pps->redundant_pic_cnt_present = get_bits1(&s->gb);
7328
7329     memset(pps->scaling_matrix4, 16, 6*16*sizeof(uint8_t));
7330     memset(pps->scaling_matrix8, 16, 2*64*sizeof(uint8_t));
7331
7332     if(get_bits_count(&s->gb) < bit_length){
7333         pps->transform_8x8_mode= get_bits1(&s->gb);
7334         decode_scaling_matrices(h, &h->sps_buffer[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
7335         get_se_golomb(&s->gb);  //second_chroma_qp_index_offset
7336     }
7337
7338     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
7339         av_log(h->s.avctx, AV_LOG_DEBUG, "pps:%d sps:%d %s slice_groups:%d ref:%d/%d %s qp:%d/%d/%d %s %s %s %s\n",
7340                pps_id, pps->sps_id,
7341                pps->cabac ? "CABAC" : "CAVLC",
7342                pps->slice_group_count,
7343                pps->ref_count[0], pps->ref_count[1],
7344                pps->weighted_pred ? "weighted" : "",
7345                pps->init_qp, pps->init_qs, pps->chroma_qp_index_offset,
7346                pps->deblocking_filter_parameters_present ? "LPAR" : "",
7347                pps->constrained_intra_pred ? "CONSTR" : "",
7348                pps->redundant_pic_cnt_present ? "REDU" : "",
7349                pps->transform_8x8_mode ? "8x8DCT" : ""
7350                );
7351     }
7352
7353     return 0;
7354 }
7355
7356 /**
7357  * finds the end of the current frame in the bitstream.
7358  * @return the position of the first byte of the next frame, or -1
7359  */
7360 static int find_frame_end(H264Context *h, const uint8_t *buf, int buf_size){
7361     int i;
7362     uint32_t state;
7363     ParseContext *pc = &(h->s.parse_context);
7364 //printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
7365 //    mb_addr= pc->mb_addr - 1;
7366     state= pc->state;
7367     for(i=0; i<=buf_size; i++){
7368         if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
7369             tprintf("find_frame_end new startcode = %08x, frame_start_found = %d, pos = %d\n", state, pc->frame_start_found, i);
7370             if(pc->frame_start_found){
7371                 // If there isn't one more byte in the buffer
7372                 // the test on first_mb_in_slice cannot be done yet
7373                 // do it at next call.
7374                 if (i >= buf_size) break;
7375                 if (buf[i] & 0x80) {
7376                     // first_mb_in_slice is 0, probably the first nal of a new
7377                     // slice
7378                     tprintf("find_frame_end frame_end_found, state = %08x, pos = %d\n", state, i);
7379                     pc->state=-1;
7380                     pc->frame_start_found= 0;
7381                     return i-4;
7382                 }
7383             }
7384             pc->frame_start_found = 1;
7385         }
7386         if((state&0xFFFFFF1F) == 0x107 || (state&0xFFFFFF1F) == 0x108 || (state&0xFFFFFF1F) == 0x109){
7387            if(pc->frame_start_found){
7388                 pc->state=-1;
7389                 pc->frame_start_found= 0;
7390                 return i-4;
7391            }
7392         }
7393         if (i<buf_size)
7394             state= (state<<8) | buf[i];
7395     }
7396
7397     pc->state= state;
7398     return END_NOT_FOUND;
7399 }
7400
7401 static int h264_parse(AVCodecParserContext *s,
7402                       AVCodecContext *avctx,
7403                       uint8_t **poutbuf, int *poutbuf_size,
7404                       const uint8_t *buf, int buf_size)
7405 {
7406     H264Context *h = s->priv_data;
7407     ParseContext *pc = &h->s.parse_context;
7408     int next;
7409
7410     next= find_frame_end(h, buf, buf_size);
7411
7412     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
7413         *poutbuf = NULL;
7414         *poutbuf_size = 0;
7415         return buf_size;
7416     }
7417
7418     *poutbuf = (uint8_t *)buf;
7419     *poutbuf_size = buf_size;
7420     return next;
7421 }
7422
7423 static int h264_split(AVCodecContext *avctx,
7424                       const uint8_t *buf, int buf_size)
7425 {
7426     int i;
7427     uint32_t state = -1;
7428     int has_sps= 0;
7429
7430     for(i=0; i<=buf_size; i++){
7431         if((state&0xFFFFFF1F) == 0x107)
7432             has_sps=1;
7433 /*        if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
7434         }*/
7435         if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){
7436             if(has_sps){
7437                 while(i>4 && buf[i-5]==0) i--;
7438                 return i-4;
7439             }
7440         }
7441         if (i<buf_size)
7442             state= (state<<8) | buf[i];
7443     }
7444     return 0;
7445 }
7446
7447
7448 static int decode_nal_units(H264Context *h, uint8_t *buf, int buf_size){
7449     MpegEncContext * const s = &h->s;
7450     AVCodecContext * const avctx= s->avctx;
7451     int buf_index=0;
7452 #if 0
7453     int i;
7454     for(i=0; i<50; i++){
7455         av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]);
7456     }
7457 #endif
7458     h->slice_num = 0;
7459     s->current_picture_ptr= NULL;
7460     for(;;){
7461         int consumed;
7462         int dst_length;
7463         int bit_length;
7464         uint8_t *ptr;
7465         int i, nalsize = 0;
7466
7467       if(h->is_avc) {
7468         if(buf_index >= buf_size) break;
7469         nalsize = 0;
7470         for(i = 0; i < h->nal_length_size; i++)
7471             nalsize = (nalsize << 8) | buf[buf_index++];
7472       } else {
7473         // start code prefix search
7474         for(; buf_index + 3 < buf_size; buf_index++){
7475             // this should allways succeed in the first iteration
7476             if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
7477                 break;
7478         }
7479
7480         if(buf_index+3 >= buf_size) break;
7481
7482         buf_index+=3;
7483       }
7484
7485         ptr= decode_nal(h, buf + buf_index, &dst_length, &consumed, h->is_avc ? nalsize : buf_size - buf_index);
7486         if(ptr[dst_length - 1] == 0) dst_length--;
7487         bit_length= 8*dst_length - decode_rbsp_trailing(ptr + dst_length - 1);
7488
7489         if(s->avctx->debug&FF_DEBUG_STARTCODE){
7490             av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", h->nal_unit_type, buf_index, buf_size, dst_length);
7491         }
7492
7493         if (h->is_avc && (nalsize != consumed))
7494             av_log(h->s.avctx, AV_LOG_ERROR, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
7495
7496         buf_index += consumed;
7497
7498         if(  (s->hurry_up == 1 && h->nal_ref_idc  == 0) //FIXME dont discard SEI id
7499            ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0))
7500             continue;
7501
7502         switch(h->nal_unit_type){
7503         case NAL_IDR_SLICE:
7504             idr(h); //FIXME ensure we don't loose some frames if there is reordering
7505         case NAL_SLICE:
7506             init_get_bits(&s->gb, ptr, bit_length);
7507             h->intra_gb_ptr=
7508             h->inter_gb_ptr= &s->gb;
7509             s->data_partitioning = 0;
7510
7511             if(decode_slice_header(h) < 0){
7512                 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
7513                 break;
7514             }
7515             if(h->redundant_pic_count==0 && s->hurry_up < 5
7516                && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
7517                && (avctx->skip_frame < AVDISCARD_BIDIR  || h->slice_type!=B_TYPE)
7518                && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
7519                && avctx->skip_frame < AVDISCARD_ALL)
7520                 decode_slice(h);
7521             break;
7522         case NAL_DPA:
7523             init_get_bits(&s->gb, ptr, bit_length);
7524             h->intra_gb_ptr=
7525             h->inter_gb_ptr= NULL;
7526             s->data_partitioning = 1;
7527
7528             if(decode_slice_header(h) < 0){
7529                 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
7530             }
7531             break;
7532         case NAL_DPB:
7533             init_get_bits(&h->intra_gb, ptr, bit_length);
7534             h->intra_gb_ptr= &h->intra_gb;
7535             break;
7536         case NAL_DPC:
7537             init_get_bits(&h->inter_gb, ptr, bit_length);
7538             h->inter_gb_ptr= &h->inter_gb;
7539
7540             if(h->redundant_pic_count==0 && h->intra_gb_ptr && s->data_partitioning
7541                && s->hurry_up < 5
7542                && (avctx->skip_frame < AVDISCARD_NONREF || h->nal_ref_idc)
7543                && (avctx->skip_frame < AVDISCARD_BIDIR  || h->slice_type!=B_TYPE)
7544                && (avctx->skip_frame < AVDISCARD_NONKEY || h->slice_type==I_TYPE)
7545                && avctx->skip_frame < AVDISCARD_ALL)
7546                 decode_slice(h);
7547             break;
7548         case NAL_SEI:
7549             init_get_bits(&s->gb, ptr, bit_length);
7550             decode_sei(h);
7551             break;
7552         case NAL_SPS:
7553             init_get_bits(&s->gb, ptr, bit_length);
7554             decode_seq_parameter_set(h);
7555
7556             if(s->flags& CODEC_FLAG_LOW_DELAY)
7557                 s->low_delay=1;
7558
7559             if(avctx->has_b_frames < 2)
7560                 avctx->has_b_frames= !s->low_delay;
7561             break;
7562         case NAL_PPS:
7563             init_get_bits(&s->gb, ptr, bit_length);
7564
7565             decode_picture_parameter_set(h, bit_length);
7566
7567             break;
7568         case NAL_AUD:
7569         case NAL_END_SEQUENCE:
7570         case NAL_END_STREAM:
7571         case NAL_FILLER_DATA:
7572         case NAL_SPS_EXT:
7573         case NAL_AUXILIARY_SLICE:
7574             break;
7575         default:
7576             av_log(avctx, AV_LOG_ERROR, "Unknown NAL code: %d\n", h->nal_unit_type);
7577         }
7578     }
7579
7580     if(!s->current_picture_ptr) return buf_index; //no frame
7581
7582     s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
7583     s->current_picture_ptr->pict_type= s->pict_type;
7584     s->current_picture_ptr->key_frame= s->pict_type == I_TYPE && h->nal_unit_type == NAL_IDR_SLICE;
7585
7586     h->prev_frame_num_offset= h->frame_num_offset;
7587     h->prev_frame_num= h->frame_num;
7588     if(s->current_picture_ptr->reference){
7589         h->prev_poc_msb= h->poc_msb;
7590         h->prev_poc_lsb= h->poc_lsb;
7591     }
7592     if(s->current_picture_ptr->reference)
7593         execute_ref_pic_marking(h, h->mmco, h->mmco_index);
7594
7595     ff_er_frame_end(s);
7596
7597     MPV_frame_end(s);
7598
7599     return buf_index;
7600 }
7601
7602 /**
7603  * returns the number of bytes consumed for building the current frame
7604  */
7605 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
7606     if(s->flags&CODEC_FLAG_TRUNCATED){
7607         pos -= s->parse_context.last_index;
7608         if(pos<0) pos=0; // FIXME remove (unneeded?)
7609
7610         return pos;
7611     }else{
7612         if(pos==0) pos=1; //avoid infinite loops (i doubt thats needed but ...)
7613         if(pos+10>buf_size) pos=buf_size; // oops ;)
7614
7615         return pos;
7616     }
7617 }
7618
7619 static int decode_frame(AVCodecContext *avctx,
7620                              void *data, int *data_size,
7621                              uint8_t *buf, int buf_size)
7622 {
7623     H264Context *h = avctx->priv_data;
7624     MpegEncContext *s = &h->s;
7625     AVFrame *pict = data;
7626     int buf_index;
7627
7628     s->flags= avctx->flags;
7629     s->flags2= avctx->flags2;
7630
7631    /* no supplementary picture */
7632     if (buf_size == 0) {
7633         return 0;
7634     }
7635
7636     if(s->flags&CODEC_FLAG_TRUNCATED){
7637         int next= find_frame_end(h, buf, buf_size);
7638
7639         if( ff_combine_frame(&s->parse_context, next, &buf, &buf_size) < 0 )
7640             return buf_size;
7641 //printf("next:%d buf_size:%d last_index:%d\n", next, buf_size, s->parse_context.last_index);
7642     }
7643
7644     if(h->is_avc && !h->got_avcC) {
7645         int i, cnt, nalsize;
7646         unsigned char *p = avctx->extradata;
7647         if(avctx->extradata_size < 7) {
7648             av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
7649             return -1;
7650         }
7651         if(*p != 1) {
7652             av_log(avctx, AV_LOG_ERROR, "Unknown avcC version %d\n", *p);
7653             return -1;
7654         }
7655         /* sps and pps in the avcC always have length coded with 2 bytes,
7656            so put a fake nal_length_size = 2 while parsing them */
7657         h->nal_length_size = 2;
7658         // Decode sps from avcC
7659         cnt = *(p+5) & 0x1f; // Number of sps
7660         p += 6;
7661         for (i = 0; i < cnt; i++) {
7662             nalsize = BE_16(p) + 2;
7663             if(decode_nal_units(h, p, nalsize) < 0) {
7664                 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
7665                 return -1;
7666             }
7667             p += nalsize;
7668         }
7669         // Decode pps from avcC
7670         cnt = *(p++); // Number of pps
7671         for (i = 0; i < cnt; i++) {
7672             nalsize = BE_16(p) + 2;
7673             if(decode_nal_units(h, p, nalsize)  != nalsize) {
7674                 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
7675                 return -1;
7676             }
7677             p += nalsize;
7678         }
7679         // Now store right nal length size, that will be use to parse all other nals
7680         h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
7681         // Do not reparse avcC
7682         h->got_avcC = 1;
7683     }
7684
7685     if(!h->is_avc && s->avctx->extradata_size && s->picture_number==0){
7686         if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0)
7687             return -1;
7688     }
7689
7690     buf_index=decode_nal_units(h, buf, buf_size);
7691     if(buf_index < 0)
7692         return -1;
7693
7694     //FIXME do something with unavailable reference frames
7695
7696 //    if(ret==FRAME_SKIPPED) return get_consumed_bytes(s, buf_index, buf_size);
7697     if(!s->current_picture_ptr){
7698         av_log(h->s.avctx, AV_LOG_DEBUG, "error, NO frame\n");
7699         return -1;
7700     }
7701
7702     {
7703         Picture *out = s->current_picture_ptr;
7704 #if 0 //decode order
7705         *data_size = sizeof(AVFrame);
7706 #else
7707         /* Sort B-frames into display order */
7708         Picture *cur = s->current_picture_ptr;
7709         Picture *prev = h->delayed_output_pic;
7710         int out_idx = 0;
7711         int pics = 0;
7712         int out_of_order;
7713         int cross_idr = 0;
7714         int dropped_frame = 0;
7715         int i;
7716
7717         if(h->sps.bitstream_restriction_flag
7718            && s->avctx->has_b_frames < h->sps.num_reorder_frames){
7719             s->avctx->has_b_frames = h->sps.num_reorder_frames;
7720             s->low_delay = 0;
7721         }
7722
7723         while(h->delayed_pic[pics]) pics++;
7724         h->delayed_pic[pics++] = cur;
7725         if(cur->reference == 0)
7726             cur->reference = 1;
7727
7728         for(i=0; h->delayed_pic[i]; i++)
7729             if(h->delayed_pic[i]->key_frame || h->delayed_pic[i]->poc==0)
7730                 cross_idr = 1;
7731
7732         out = h->delayed_pic[0];
7733         for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame; i++)
7734             if(h->delayed_pic[i]->poc < out->poc){
7735                 out = h->delayed_pic[i];
7736                 out_idx = i;
7737             }
7738
7739         out_of_order = !cross_idr && prev && out->poc < prev->poc;
7740         if(prev && pics <= s->avctx->has_b_frames)
7741             out = prev;
7742         else if((out_of_order && pics-1 == s->avctx->has_b_frames && pics < 15)
7743            || (s->low_delay &&
7744             ((!cross_idr && prev && out->poc > prev->poc + 2)
7745              || cur->pict_type == B_TYPE)))
7746         {
7747             s->low_delay = 0;
7748             s->avctx->has_b_frames++;
7749             out = prev;
7750         }
7751         else if(out_of_order)
7752             out = prev;
7753
7754         if(out_of_order || pics > s->avctx->has_b_frames){
7755             dropped_frame = (out != h->delayed_pic[out_idx]);
7756             for(i=out_idx; h->delayed_pic[i]; i++)
7757                 h->delayed_pic[i] = h->delayed_pic[i+1];
7758         }
7759
7760         if(prev == out && !dropped_frame)
7761             *data_size = 0;
7762         else
7763             *data_size = sizeof(AVFrame);
7764         if(prev && prev != out && prev->reference == 1)
7765             prev->reference = 0;
7766         h->delayed_output_pic = out;
7767 #endif
7768
7769         if(out)
7770             *pict= *(AVFrame*)out;
7771         else
7772             av_log(avctx, AV_LOG_DEBUG, "no picture\n");
7773     }
7774
7775     assert(pict->data[0] || !*data_size);
7776     ff_print_debug_info(s, pict);
7777 //printf("out %d\n", (int)pict->data[0]);
7778 #if 0 //?
7779
7780     /* Return the Picture timestamp as the frame number */
7781     /* we substract 1 because it is added on utils.c    */
7782     avctx->frame_number = s->picture_number - 1;
7783 #endif
7784     return get_consumed_bytes(s, buf_index, buf_size);
7785 }
7786 #if 0
7787 static inline void fill_mb_avail(H264Context *h){
7788     MpegEncContext * const s = &h->s;
7789     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
7790
7791     if(s->mb_y){
7792         h->mb_avail[0]= s->mb_x                 && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
7793         h->mb_avail[1]=                            h->slice_table[mb_xy - s->mb_stride    ] == h->slice_num;
7794         h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
7795     }else{
7796         h->mb_avail[0]=
7797         h->mb_avail[1]=
7798         h->mb_avail[2]= 0;
7799     }
7800     h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
7801     h->mb_avail[4]= 1; //FIXME move out
7802     h->mb_avail[5]= 0; //FIXME move out
7803 }
7804 #endif
7805
7806 #if 0 //selftest
7807 #define COUNT 8000
7808 #define SIZE (COUNT*40)
7809 int main(){
7810     int i;
7811     uint8_t temp[SIZE];
7812     PutBitContext pb;
7813     GetBitContext gb;
7814 //    int int_temp[10000];
7815     DSPContext dsp;
7816     AVCodecContext avctx;
7817
7818     dsputil_init(&dsp, &avctx);
7819
7820     init_put_bits(&pb, temp, SIZE);
7821     printf("testing unsigned exp golomb\n");
7822     for(i=0; i<COUNT; i++){
7823         START_TIMER
7824         set_ue_golomb(&pb, i);
7825         STOP_TIMER("set_ue_golomb");
7826     }
7827     flush_put_bits(&pb);
7828
7829     init_get_bits(&gb, temp, 8*SIZE);
7830     for(i=0; i<COUNT; i++){
7831         int j, s;
7832
7833         s= show_bits(&gb, 24);
7834
7835         START_TIMER
7836         j= get_ue_golomb(&gb);
7837         if(j != i){
7838             printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
7839 //            return -1;
7840         }
7841         STOP_TIMER("get_ue_golomb");
7842     }
7843
7844
7845     init_put_bits(&pb, temp, SIZE);
7846     printf("testing signed exp golomb\n");
7847     for(i=0; i<COUNT; i++){
7848         START_TIMER
7849         set_se_golomb(&pb, i - COUNT/2);
7850         STOP_TIMER("set_se_golomb");
7851     }
7852     flush_put_bits(&pb);
7853
7854     init_get_bits(&gb, temp, 8*SIZE);
7855     for(i=0; i<COUNT; i++){
7856         int j, s;
7857
7858         s= show_bits(&gb, 24);
7859
7860         START_TIMER
7861         j= get_se_golomb(&gb);
7862         if(j != i - COUNT/2){
7863             printf("missmatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
7864 //            return -1;
7865         }
7866         STOP_TIMER("get_se_golomb");
7867     }
7868
7869     printf("testing 4x4 (I)DCT\n");
7870
7871     DCTELEM block[16];
7872     uint8_t src[16], ref[16];
7873     uint64_t error= 0, max_error=0;
7874
7875     for(i=0; i<COUNT; i++){
7876         int j;
7877 //        printf("%d %d %d\n", r1, r2, (r2-r1)*16);
7878         for(j=0; j<16; j++){
7879             ref[j]= random()%255;
7880             src[j]= random()%255;
7881         }
7882
7883         h264_diff_dct_c(block, src, ref, 4);
7884
7885         //normalize
7886         for(j=0; j<16; j++){
7887 //            printf("%d ", block[j]);
7888             block[j]= block[j]*4;
7889             if(j&1) block[j]= (block[j]*4 + 2)/5;
7890             if(j&4) block[j]= (block[j]*4 + 2)/5;
7891         }
7892 //        printf("\n");
7893
7894         s->dsp.h264_idct_add(ref, block, 4);
7895 /*        for(j=0; j<16; j++){
7896             printf("%d ", ref[j]);
7897         }
7898         printf("\n");*/
7899
7900         for(j=0; j<16; j++){
7901             int diff= ABS(src[j] - ref[j]);
7902
7903             error+= diff*diff;
7904             max_error= FFMAX(max_error, diff);
7905         }
7906     }
7907     printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
7908 #if 0
7909     printf("testing quantizer\n");
7910     for(qp=0; qp<52; qp++){
7911         for(i=0; i<16; i++)
7912             src1_block[i]= src2_block[i]= random()%255;
7913
7914     }
7915 #endif
7916     printf("Testing NAL layer\n");
7917
7918     uint8_t bitstream[COUNT];
7919     uint8_t nal[COUNT*2];
7920     H264Context h;
7921     memset(&h, 0, sizeof(H264Context));
7922
7923     for(i=0; i<COUNT; i++){
7924         int zeros= i;
7925         int nal_length;
7926         int consumed;
7927         int out_length;
7928         uint8_t *out;
7929         int j;
7930
7931         for(j=0; j<COUNT; j++){
7932             bitstream[j]= (random() % 255) + 1;
7933         }
7934
7935         for(j=0; j<zeros; j++){
7936             int pos= random() % COUNT;
7937             while(bitstream[pos] == 0){
7938                 pos++;
7939                 pos %= COUNT;
7940             }
7941             bitstream[pos]=0;
7942         }
7943
7944         START_TIMER
7945
7946         nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
7947         if(nal_length<0){
7948             printf("encoding failed\n");
7949             return -1;
7950         }
7951
7952         out= decode_nal(&h, nal, &out_length, &consumed, nal_length);
7953
7954         STOP_TIMER("NAL")
7955
7956         if(out_length != COUNT){
7957             printf("incorrect length %d %d\n", out_length, COUNT);
7958             return -1;
7959         }
7960
7961         if(consumed != nal_length){
7962             printf("incorrect consumed length %d %d\n", nal_length, consumed);
7963             return -1;
7964         }
7965
7966         if(memcmp(bitstream, out, COUNT)){
7967             printf("missmatch\n");
7968             return -1;
7969         }
7970     }
7971
7972     printf("Testing RBSP\n");
7973
7974
7975     return 0;
7976 }
7977 #endif
7978
7979
7980 static int decode_end(AVCodecContext *avctx)
7981 {
7982     H264Context *h = avctx->priv_data;
7983     MpegEncContext *s = &h->s;
7984
7985     av_freep(&h->rbsp_buffer);
7986     free_tables(h); //FIXME cleanup init stuff perhaps
7987     MPV_common_end(s);
7988
7989 //    memset(h, 0, sizeof(H264Context));
7990
7991     return 0;
7992 }
7993
7994
7995 AVCodec h264_decoder = {
7996     "h264",
7997     CODEC_TYPE_VIDEO,
7998     CODEC_ID_H264,
7999     sizeof(H264Context),
8000     decode_init,
8001     NULL,
8002     decode_end,
8003     decode_frame,
8004     /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
8005     .flush= flush_dpb,
8006 };
8007
8008 AVCodecParser h264_parser = {
8009     { CODEC_ID_H264 },
8010     sizeof(H264Context),
8011     NULL,
8012     h264_parse,
8013     ff_parse_close,
8014     h264_split,
8015 };
8016
8017 #include "svq3.c"