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