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