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