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