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

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... 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
  24  * H.264 / AVC / MPEG4 part10 codec.
  25  * @author Michael Niedermayer <michaelni@gmx.at>
  26  */
  27
  28 #include "libavutil/imgutils.h"
  29 #include "internal.h"
  30 #include "dsputil.h"
  31 #include "avcodec.h"
  32 #include "mpegvideo.h"
  33 #include "h264.h"
  34 #include "h264data.h"
  35 #include "h264_mvpred.h"
  36 #include "golomb.h"
  37 #include "mathops.h"
  38 #include "rectangle.h"
  39 #include "thread.h"
  40 #include "vdpau_internal.h"
  41 #include "libavutil/avassert.h"
  42
  43 #include "cabac.h"
  44
  45 //#undef NDEBUG
  46 #include <assert.h>
  47
  48 static const uint8_t rem6[QP_MAX_NUM+1]={
  49 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, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3,
  50 };
  51
  52 static const uint8_t div6[QP_MAX_NUM+1]={
  53 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, 8, 8, 9, 9, 9, 9, 9, 9,10,10,10,10,
  54 };
  55
  56 static const enum PixelFormat hwaccel_pixfmt_list_h264_jpeg_420[] = {
  57     PIX_FMT_DXVA2_VLD,
  58     PIX_FMT_VAAPI_VLD,
  59     PIX_FMT_YUVJ420P,
  60     PIX_FMT_NONE
  61 };
  62
  63 void ff_h264_write_back_intra_pred_mode(H264Context *h){
  64     int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
  65
  66     AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
  67     mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
  68     mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
  69     mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
  70 }
  71
  72 /**
  73  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
  74  */
  75 int ff_h264_check_intra4x4_pred_mode(H264Context *h){
  76     MpegEncContext * const s = &h->s;
  77     static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0};
  78     static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED};
  79     int i;
  80
  81     if(!(h->top_samples_available&0x8000)){
  82         for(i=0; i<4; i++){
  83             int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ];
  84             if(status<0){
  85                 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);
  86                 return -1;
  87             } else if(status){
  88                 h->intra4x4_pred_mode_cache[scan8[0] + i]= status;
  89             }
  90         }
  91     }
  92
  93     if((h->left_samples_available&0x8888)!=0x8888){
  94         static const int mask[4]={0x8000,0x2000,0x80,0x20};
  95         for(i=0; i<4; i++){
  96             if(!(h->left_samples_available&mask[i])){
  97                 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ];
  98                 if(status<0){
  99                     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);
 100                     return -1;
 101                 } else if(status){
 102                     h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status;
 103                 }
 104             }
 105         }
 106     }
 107
 108     return 0;
 109 } //FIXME cleanup like ff_h264_check_intra_pred_mode
 110
 111 /**
 112  * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 113  */
 114 int ff_h264_check_intra_pred_mode(H264Context *h, int mode){
 115     MpegEncContext * const s = &h->s;
 116     static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
 117     static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
 118
 119     if(mode > 6U) {
 120         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);
 121         return -1;
 122     }
 123
 124     if(!(h->top_samples_available&0x8000)){
 125         mode= top[ mode ];
 126         if(mode<0){
 127             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);
 128             return -1;
 129         }
 130     }
 131
 132     if((h->left_samples_available&0x8080) != 0x8080){
 133         mode= left[ mode ];
 134         if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
 135             mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
 136         }
 137         if(mode<0){
 138             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);
 139             return -1;
 140         }
 141     }
 142
 143     return mode;
 144 }
 145
 146 const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
 147     int i, si, di;
 148     uint8_t *dst;
 149     int bufidx;
 150
 151 //    src[0]&0x80;                //forbidden bit
 152     h->nal_ref_idc= src[0]>>5;
 153     h->nal_unit_type= src[0]&0x1F;
 154
 155     src++; length--;
 156
 157 #if HAVE_FAST_UNALIGNED
 158 # if HAVE_FAST_64BIT
 159 #   define RS 7
 160     for(i=0; i+1<length; i+=9){
 161         if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL))
 162 # else
 163 #   define RS 3
 164     for(i=0; i+1<length; i+=5){
 165         if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U))
 166 # endif
 167             continue;
 168         if(i>0 && !src[i]) i--;
 169         while(src[i]) i++;
 170 #else
 171 #   define RS 0
 172     for(i=0; i+1<length; i+=2){
 173         if(src[i]) continue;
 174         if(i>0 && src[i-1]==0) i--;
 175 #endif
 176         if(i+2<length && src[i+1]==0 && src[i+2]<=3){
 177             if(src[i+2]!=3){
 178                 /* startcode, so we must be past the end */
 179                 length=i;
 180             }
 181             break;
 182         }
 183         i-= RS;
 184     }
 185
 186     if(i>=length-1){ //no escaped 0
 187         *dst_length= length;
 188         *consumed= length+1; //+1 for the header
 189         return src;
 190     }
 191
 192     bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
 193     av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
 194     dst= h->rbsp_buffer[bufidx];
 195
 196     if (dst == NULL){
 197         return NULL;
 198     }
 199
 200 //printf("decoding esc\n");
 201     memcpy(dst, src, i);
 202     si=di=i;
 203     while(si+2<length){
 204         //remove escapes (very rare 1:2^22)
 205         if(src[si+2]>3){
 206             dst[di++]= src[si++];
 207             dst[di++]= src[si++];
 208         }else if(src[si]==0 && src[si+1]==0){
 209             if(src[si+2]==3){ //escape
 210                 dst[di++]= 0;
 211                 dst[di++]= 0;
 212                 si+=3;
 213                 continue;
 214             }else //next start code
 215                 goto nsc;
 216         }
 217
 218         dst[di++]= src[si++];
 219     }
 220     while(si<length)
 221         dst[di++]= src[si++];
 222 nsc:
 223
 224     memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 225
 226     *dst_length= di;
 227     *consumed= si + 1;//+1 for the header
 228 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding)
 229     return dst;
 230 }
 231
 232 /**
 233  * Identify the exact end of the bitstream
 234  * @return the length of the trailing, or 0 if damaged
 235  */
 236 static int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){
 237     int v= *src;
 238     int r;
 239
 240     tprintf(h->s.avctx, "rbsp trailing %X\n", v);
 241
 242     for(r=1; r<9; r++){
 243         if(v&1) return r;
 244         v>>=1;
 245     }
 246     return 0;
 247 }
 248
 249 static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height,
 250                                  int y_offset, int list){
 251     int raw_my= h->mv_cache[list][ scan8[n] ][1];
 252     int filter_height= (raw_my&3) ? 2 : 0;
 253     int full_my= (raw_my>>2) + y_offset;
 254     int top = full_my - filter_height, bottom = full_my + height + filter_height;
 255
 256     return FFMAX(abs(top), bottom);
 257 }
 258
 259 static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n, int height,
 260                                int y_offset, int list0, int list1, int *nrefs){
 261     MpegEncContext * const s = &h->s;
 262     int my;
 263
 264     y_offset += 16*(s->mb_y >> MB_FIELD);
 265
 266     if(list0){
 267         int ref_n = h->ref_cache[0][ scan8[n] ];
 268         Picture *ref= &h->ref_list[0][ref_n];
 269
 270         // Error resilience puts the current picture in the ref list.
 271         // Don't try to wait on these as it will cause a deadlock.
 272         // Fields can wait on each other, though.
 273         if(ref->thread_opaque != s->current_picture.thread_opaque ||
 274            (ref->reference&3) != s->picture_structure) {
 275             my = get_lowest_part_list_y(h, ref, n, height, y_offset, 0);
 276             if (refs[0][ref_n] < 0) nrefs[0] += 1;
 277             refs[0][ref_n] = FFMAX(refs[0][ref_n], my);
 278         }
 279     }
 280
 281     if(list1){
 282         int ref_n = h->ref_cache[1][ scan8[n] ];
 283         Picture *ref= &h->ref_list[1][ref_n];
 284
 285         if(ref->thread_opaque != s->current_picture.thread_opaque ||
 286            (ref->reference&3) != s->picture_structure) {
 287             my = get_lowest_part_list_y(h, ref, n, height, y_offset, 1);
 288             if (refs[1][ref_n] < 0) nrefs[1] += 1;
 289             refs[1][ref_n] = FFMAX(refs[1][ref_n], my);
 290         }
 291     }
 292 }
 293
 294 /**
 295  * Wait until all reference frames are available for MC operations.
 296  *
 297  * @param h the H264 context
 298  */
 299 static void await_references(H264Context *h){
 300     MpegEncContext * const s = &h->s;
 301     const int mb_xy= h->mb_xy;
 302     const int mb_type= s->current_picture.mb_type[mb_xy];
 303     int refs[2][48];
 304     int nrefs[2] = {0};
 305     int ref, list;
 306
 307     memset(refs, -1, sizeof(refs));
 308
 309     if(IS_16X16(mb_type)){
 310         get_lowest_part_y(h, refs, 0, 16, 0,
 311                   IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
 312     }else if(IS_16X8(mb_type)){
 313         get_lowest_part_y(h, refs, 0, 8, 0,
 314                   IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
 315         get_lowest_part_y(h, refs, 8, 8, 8,
 316                   IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
 317     }else if(IS_8X16(mb_type)){
 318         get_lowest_part_y(h, refs, 0, 16, 0,
 319                   IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1), nrefs);
 320         get_lowest_part_y(h, refs, 4, 16, 0,
 321                   IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1), nrefs);
 322     }else{
 323         int i;
 324
 325         assert(IS_8X8(mb_type));
 326
 327         for(i=0; i<4; i++){
 328             const int sub_mb_type= h->sub_mb_type[i];
 329             const int n= 4*i;
 330             int y_offset= (i&2)<<2;
 331
 332             if(IS_SUB_8X8(sub_mb_type)){
 333                 get_lowest_part_y(h, refs, n  , 8, y_offset,
 334                           IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 335             }else if(IS_SUB_8X4(sub_mb_type)){
 336                 get_lowest_part_y(h, refs, n  , 4, y_offset,
 337                           IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 338                 get_lowest_part_y(h, refs, n+2, 4, y_offset+4,
 339                           IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 340             }else if(IS_SUB_4X8(sub_mb_type)){
 341                 get_lowest_part_y(h, refs, n  , 8, y_offset,
 342                           IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 343                 get_lowest_part_y(h, refs, n+1, 8, y_offset,
 344                           IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 345             }else{
 346                 int j;
 347                 assert(IS_SUB_4X4(sub_mb_type));
 348                 for(j=0; j<4; j++){
 349                     int sub_y_offset= y_offset + 2*(j&2);
 350                     get_lowest_part_y(h, refs, n+j, 4, sub_y_offset,
 351                               IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1), nrefs);
 352                 }
 353             }
 354         }
 355     }
 356
 357     for(list=h->list_count-1; list>=0; list--){
 358         for(ref=0; ref<48 && nrefs[list]; ref++){
 359             int row = refs[list][ref];
 360             if(row >= 0){
 361                 Picture *ref_pic = &h->ref_list[list][ref];
 362                 int ref_field = ref_pic->reference - 1;
 363                 int ref_field_picture = ref_pic->field_picture;
 364                 int pic_height = 16*s->mb_height >> ref_field_picture;
 365
 366                 row <<= MB_MBAFF;
 367                 nrefs[list]--;
 368
 369                 if(!FIELD_PICTURE && ref_field_picture){ // frame referencing two fields
 370                     ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1) - !(row&1), pic_height-1), 1);
 371                     ff_thread_await_progress((AVFrame*)ref_pic, FFMIN((row >> 1)           , pic_height-1), 0);
 372                 }else if(FIELD_PICTURE && !ref_field_picture){ // field referencing one field of a frame
 373                     ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row*2 + ref_field    , pic_height-1), 0);
 374                 }else if(FIELD_PICTURE){
 375                     ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), ref_field);
 376                 }else{
 377                     ff_thread_await_progress((AVFrame*)ref_pic, FFMIN(row, pic_height-1), 0);
 378                 }
 379             }
 380         }
 381     }
 382 }
 383
 384 #if 0
 385 /**
 386  * DCT transforms the 16 dc values.
 387  * @param qp quantization parameter ??? FIXME
 388  */
 389 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){
 390 //    const int qmul= dequant_coeff[qp][0];
 391     int i;
 392     int temp[16]; //FIXME check if this is a good idea
 393     static const int x_offset[4]={0, 1*stride, 4* stride,  5*stride};
 394     static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride};
 395
 396     for(i=0; i<4; i++){
 397         const int offset= y_offset[i];
 398         const int z0= block[offset+stride*0] + block[offset+stride*4];
 399         const int z1= block[offset+stride*0] - block[offset+stride*4];
 400         const int z2= block[offset+stride*1] - block[offset+stride*5];
 401         const int z3= block[offset+stride*1] + block[offset+stride*5];
 402
 403         temp[4*i+0]= z0+z3;
 404         temp[4*i+1]= z1+z2;
 405         temp[4*i+2]= z1-z2;
 406         temp[4*i+3]= z0-z3;
 407     }
 408
 409     for(i=0; i<4; i++){
 410         const int offset= x_offset[i];
 411         const int z0= temp[4*0+i] + temp[4*2+i];
 412         const int z1= temp[4*0+i] - temp[4*2+i];
 413         const int z2= temp[4*1+i] - temp[4*3+i];
 414         const int z3= temp[4*1+i] + temp[4*3+i];
 415
 416         block[stride*0 +offset]= (z0 + z3)>>1;
 417         block[stride*2 +offset]= (z1 + z2)>>1;
 418         block[stride*8 +offset]= (z1 - z2)>>1;
 419         block[stride*10+offset]= (z0 - z3)>>1;
 420     }
 421 }
 422 #endif
 423
 424 #undef xStride
 425 #undef stride
 426
 427 #if 0
 428 static void chroma_dc_dct_c(DCTELEM *block){
 429     const int stride= 16*2;
 430     const int xStride= 16;
 431     int a,b,c,d,e;
 432
 433     a= block[stride*0 + xStride*0];
 434     b= block[stride*0 + xStride*1];
 435     c= block[stride*1 + xStride*0];
 436     d= block[stride*1 + xStride*1];
 437
 438     e= a-b;
 439     a= a+b;
 440     b= c-d;
 441     c= c+d;
 442
 443     block[stride*0 + xStride*0]= (a+c);
 444     block[stride*0 + xStride*1]= (e+b);
 445     block[stride*1 + xStride*0]= (a-c);
 446     block[stride*1 + xStride*1]= (e-b);
 447 }
 448 #endif
 449
 450 static void free_tables(H264Context *h, int free_rbsp){
 451     int i;
 452     H264Context *hx;
 453
 454     av_freep(&h->intra4x4_pred_mode);
 455     av_freep(&h->chroma_pred_mode_table);
 456     av_freep(&h->cbp_table);
 457     av_freep(&h->mvd_table[0]);
 458     av_freep(&h->mvd_table[1]);
 459     av_freep(&h->direct_table);
 460     av_freep(&h->non_zero_count);
 461     av_freep(&h->slice_table_base);
 462     h->slice_table= NULL;
 463     av_freep(&h->list_counts);
 464
 465     av_freep(&h->mb2b_xy);
 466     av_freep(&h->mb2br_xy);
 467
 468     for(i = 0; i < MAX_THREADS; i++) {
 469         hx = h->thread_context[i];
 470         if(!hx) continue;
 471         av_freep(&hx->top_borders[1]);
 472         av_freep(&hx->top_borders[0]);
 473         av_freep(&hx->s.obmc_scratchpad);
 474         if (free_rbsp){
 475             av_freep(&hx->rbsp_buffer[1]);
 476             av_freep(&hx->rbsp_buffer[0]);
 477             hx->rbsp_buffer_size[0] = 0;
 478             hx->rbsp_buffer_size[1] = 0;
 479         }
 480         if (i) av_freep(&h->thread_context[i]);
 481     }
 482 }
 483
 484 static void init_dequant8_coeff_table(H264Context *h){
 485     int i,q,x;
 486     const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
 487     h->dequant8_coeff[0] = h->dequant8_buffer[0];
 488     h->dequant8_coeff[1] = h->dequant8_buffer[1];
 489
 490     for(i=0; i<2; i++ ){
 491         if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){
 492             h->dequant8_coeff[1] = h->dequant8_buffer[0];
 493             break;
 494         }
 495
 496         for(q=0; q<max_qp+1; q++){
 497             int shift = div6[q];
 498             int idx = rem6[q];
 499             for(x=0; x<64; x++)
 500                 h->dequant8_coeff[i][q][(x>>3)|((x&7)<<3)] =
 501                     ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] *
 502                     h->pps.scaling_matrix8[i][x]) << shift;
 503         }
 504     }
 505 }
 506
 507 static void init_dequant4_coeff_table(H264Context *h){
 508     int i,j,q,x;
 509     const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
 510     for(i=0; i<6; i++ ){
 511         h->dequant4_coeff[i] = h->dequant4_buffer[i];
 512         for(j=0; j<i; j++){
 513             if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){
 514                 h->dequant4_coeff[i] = h->dequant4_buffer[j];
 515                 break;
 516             }
 517         }
 518         if(j<i)
 519             continue;
 520
 521         for(q=0; q<max_qp+1; q++){
 522             int shift = div6[q] + 2;
 523             int idx = rem6[q];
 524             for(x=0; x<16; x++)
 525                 h->dequant4_coeff[i][q][(x>>2)|((x<<2)&0xF)] =
 526                     ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] *
 527                     h->pps.scaling_matrix4[i][x]) << shift;
 528         }
 529     }
 530 }
 531
 532 static void init_dequant_tables(H264Context *h){
 533     int i,x;
 534     init_dequant4_coeff_table(h);
 535     if(h->pps.transform_8x8_mode)
 536         init_dequant8_coeff_table(h);
 537     if(h->sps.transform_bypass){
 538         for(i=0; i<6; i++)
 539             for(x=0; x<16; x++)
 540                 h->dequant4_coeff[i][0][x] = 1<<6;
 541         if(h->pps.transform_8x8_mode)
 542             for(i=0; i<2; i++)
 543                 for(x=0; x<64; x++)
 544                     h->dequant8_coeff[i][0][x] = 1<<6;
 545     }
 546 }
 547
 548
 549 int ff_h264_alloc_tables(H264Context *h){
 550     MpegEncContext * const s = &h->s;
 551     const int big_mb_num= s->mb_stride * (s->mb_height+1);
 552     const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count;
 553     int x,y;
 554
 555     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8  * sizeof(uint8_t), fail)
 556
 557     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count    , big_mb_num * 32 * sizeof(uint8_t), fail)
 558     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base  , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail)
 559     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail)
 560
 561     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail)
 562     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail);
 563     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail);
 564     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail);
 565     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail)
 566
 567     memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride)  * sizeof(*h->slice_table_base));
 568     h->slice_table= h->slice_table_base + s->mb_stride*2 + 1;
 569
 570     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy  , big_mb_num * sizeof(uint32_t), fail);
 571     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail);
 572     for(y=0; y<s->mb_height; y++){
 573         for(x=0; x<s->mb_width; x++){
 574             const int mb_xy= x + y*s->mb_stride;
 575             const int b_xy = 4*x + 4*y*h->b_stride;
 576
 577             h->mb2b_xy [mb_xy]= b_xy;
 578             h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride)));
 579         }
 580     }
 581
 582     s->obmc_scratchpad = NULL;
 583
 584     if(!h->dequant4_coeff[0])
 585         init_dequant_tables(h);
 586
 587     return 0;
 588 fail:
 589     free_tables(h, 1);
 590     return -1;
 591 }
 592
 593 /**
 594  * Mimic alloc_tables(), but for every context thread.
 595  */
 596 static void clone_tables(H264Context *dst, H264Context *src, int i){
 597     MpegEncContext * const s = &src->s;
 598     dst->intra4x4_pred_mode       = src->intra4x4_pred_mode + i*8*2*s->mb_stride;
 599     dst->non_zero_count           = src->non_zero_count;
 600     dst->slice_table              = src->slice_table;
 601     dst->cbp_table                = src->cbp_table;
 602     dst->mb2b_xy                  = src->mb2b_xy;
 603     dst->mb2br_xy                 = src->mb2br_xy;
 604     dst->chroma_pred_mode_table   = src->chroma_pred_mode_table;
 605     dst->mvd_table[0]             = src->mvd_table[0] + i*8*2*s->mb_stride;
 606     dst->mvd_table[1]             = src->mvd_table[1] + i*8*2*s->mb_stride;
 607     dst->direct_table             = src->direct_table;
 608     dst->list_counts              = src->list_counts;
 609
 610     dst->s.obmc_scratchpad = NULL;
 611     ff_h264_pred_init(&dst->hpc, src->s.codec_id, src->sps.bit_depth_luma);
 612 }
 613
 614 /**
 615  * Init context
 616  * Allocate buffers which are not shared amongst multiple threads.
 617  */
 618 static int context_init(H264Context *h){
 619     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t)*2, fail)
 620     FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t)*2, fail)
 621
 622     h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] =
 623     h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE;
 624
 625     return 0;
 626 fail:
 627     return -1; // free_tables will clean up for us
 628 }
 629
 630 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size);
 631
 632 static av_cold void common_init(H264Context *h){
 633     MpegEncContext * const s = &h->s;
 634
 635     s->width = s->avctx->width;
 636     s->height = s->avctx->height;
 637     s->codec_id= s->avctx->codec->id;
 638
 639     ff_h264dsp_init(&h->h264dsp, 8);
 640     ff_h264_pred_init(&h->hpc, s->codec_id, 8);
 641
 642     h->dequant_coeff_pps= -1;
 643     s->unrestricted_mv=1;
 644     s->decode=1; //FIXME
 645
 646     dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
 647
 648     memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
 649     memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
 650 }
 651
 652 int ff_h264_decode_extradata(H264Context *h)
 653 {
 654     AVCodecContext *avctx = h->s.avctx;
 655
 656     if(*(char *)avctx->extradata == 1){
 657         int i, cnt, nalsize;
 658         unsigned char *p = avctx->extradata;
 659
 660         h->is_avc = 1;
 661
 662         if(avctx->extradata_size < 7) {
 663             av_log(avctx, AV_LOG_ERROR, "avcC too short\n");
 664             return -1;
 665         }
 666         /* sps and pps in the avcC always have length coded with 2 bytes,
 667            so put a fake nal_length_size = 2 while parsing them */
 668         h->nal_length_size = 2;
 669         // Decode sps from avcC
 670         cnt = *(p+5) & 0x1f; // Number of sps
 671         p += 6;
 672         for (i = 0; i < cnt; i++) {
 673             nalsize = AV_RB16(p) + 2;
 674             if(decode_nal_units(h, p, nalsize) < 0) {
 675                 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
 676                 return -1;
 677             }
 678             p += nalsize;
 679         }
 680         // Decode pps from avcC
 681         cnt = *(p++); // Number of pps
 682         for (i = 0; i < cnt; i++) {
 683             nalsize = AV_RB16(p) + 2;
 684             if(decode_nal_units(h, p, nalsize) < 0) {
 685                 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
 686                 return -1;
 687             }
 688             p += nalsize;
 689         }
 690         // Now store right nal length size, that will be use to parse all other nals
 691         h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1;
 692     } else {
 693         h->is_avc = 0;
 694         if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)
 695             return -1;
 696     }
 697     return 0;
 698 }
 699
 700 av_cold int ff_h264_decode_init(AVCodecContext *avctx){
 701     H264Context *h= avctx->priv_data;
 702     MpegEncContext * const s = &h->s;
 703
 704     MPV_decode_defaults(s);
 705
 706     s->avctx = avctx;
 707     common_init(h);
 708
 709     s->out_format = FMT_H264;
 710     s->workaround_bugs= avctx->workaround_bugs;
 711
 712     // set defaults
 713 //    s->decode_mb= ff_h263_decode_mb;
 714     s->quarter_sample = 1;
 715     if(!avctx->has_b_frames)
 716     s->low_delay= 1;
 717
 718     avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
 719
 720     ff_h264_decode_init_vlc();
 721
 722     h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;
 723     h->pixel_shift = 0;
 724     h->sps.bit_depth_luma = avctx->bits_per_raw_sample = 8;
 725
 726     h->thread_context[0] = h;
 727     h->outputed_poc = h->next_outputed_poc = INT_MIN;
 728     h->prev_poc_msb= 1<<16;
 729     h->x264_build = -1;
 730     ff_h264_reset_sei(h);
 731     if(avctx->codec_id == CODEC_ID_H264){
 732         if(avctx->ticks_per_frame == 1){
 733             s->avctx->time_base.den *=2;
 734         }
 735         avctx->ticks_per_frame = 2;
 736     }
 737
 738     if(avctx->extradata_size > 0 && avctx->extradata &&
 739         ff_h264_decode_extradata(h))
 740         return -1;
 741
 742     if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){
 743         s->avctx->has_b_frames = h->sps.num_reorder_frames;
 744         s->low_delay = 0;
 745     }
 746
 747     return 0;
 748 }
 749
 750
 751 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b)+(size))))
 752 static void copy_picture_range(Picture **to, Picture **from, int count, MpegEncContext *new_base, MpegEncContext *old_base)
 753 {
 754     int i;
 755
 756     for (i=0; i<count; i++){
 757         assert((IN_RANGE(from[i], old_base, sizeof(*old_base)) ||
 758                 IN_RANGE(from[i], old_base->picture, sizeof(Picture) * old_base->picture_count) ||
 759                 !from[i]));
 760         to[i] = REBASE_PICTURE(from[i], new_base, old_base);
 761     }
 762 }
 763
 764 static void copy_parameter_set(void **to, void **from, int count, int size)
 765 {
 766     int i;
 767
 768     for (i=0; i<count; i++){
 769         if (to[i] && !from[i]) av_freep(&to[i]);
 770         else if (from[i] && !to[i]) to[i] = av_malloc(size);
 771
 772         if (from[i]) memcpy(to[i], from[i], size);
 773     }
 774 }
 775
 776 static int decode_init_thread_copy(AVCodecContext *avctx){
 777     H264Context *h= avctx->priv_data;
 778
 779     if (!avctx->is_copy) return 0;
 780     memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
 781     memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
 782
 783     return 0;
 784 }
 785
 786 #define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)
 787 static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){
 788     H264Context *h= dst->priv_data, *h1= src->priv_data;
 789     MpegEncContext * const s = &h->s, * const s1 = &h1->s;
 790     int inited = s->context_initialized, err;
 791     int i;
 792
 793     if(dst == src || !s1->context_initialized) return 0;
 794
 795     err = ff_mpeg_update_thread_context(dst, src);
 796     if(err) return err;
 797
 798     //FIXME handle width/height changing
 799     if(!inited){
 800         for(i = 0; i < MAX_SPS_COUNT; i++)
 801             av_freep(h->sps_buffers + i);
 802
 803         for(i = 0; i < MAX_PPS_COUNT; i++)
 804             av_freep(h->pps_buffers + i);
 805
 806         memcpy(&h->s + 1, &h1->s + 1, sizeof(H264Context) - sizeof(MpegEncContext)); //copy all fields after MpegEnc
 807         memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
 808         memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
 809         ff_h264_alloc_tables(h);
 810         context_init(h);
 811
 812         for(i=0; i<2; i++){
 813             h->rbsp_buffer[i] = NULL;
 814             h->rbsp_buffer_size[i] = 0;
 815         }
 816
 817         h->thread_context[0] = h;
 818
 819         // frame_start may not be called for the next thread (if it's decoding a bottom field)
 820         // so this has to be allocated here
 821         h->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
 822
 823         s->dsp.clear_blocks(h->mb);
 824     }
 825
 826     //extradata/NAL handling
 827     h->is_avc          = h1->is_avc;
 828
 829     //SPS/PPS
 830     copy_parameter_set((void**)h->sps_buffers, (void**)h1->sps_buffers, MAX_SPS_COUNT, sizeof(SPS));
 831     h->sps             = h1->sps;
 832     copy_parameter_set((void**)h->pps_buffers, (void**)h1->pps_buffers, MAX_PPS_COUNT, sizeof(PPS));
 833     h->pps             = h1->pps;
 834
 835     //Dequantization matrices
 836     //FIXME these are big - can they be only copied when PPS changes?
 837     copy_fields(h, h1, dequant4_buffer, dequant4_coeff);
 838
 839     for(i=0; i<6; i++)
 840         h->dequant4_coeff[i] = h->dequant4_buffer[0] + (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);
 841
 842     for(i=0; i<2; i++)
 843         h->dequant8_coeff[i] = h->dequant8_buffer[0] + (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);
 844
 845     h->dequant_coeff_pps = h1->dequant_coeff_pps;
 846
 847     //POC timing
 848     copy_fields(h, h1, poc_lsb, redundant_pic_count);
 849
 850     //reference lists
 851     copy_fields(h, h1, ref_count, list_count);
 852     copy_fields(h, h1, ref_list,  intra_gb);
 853     copy_fields(h, h1, short_ref, cabac_init_idc);
 854
 855     copy_picture_range(h->short_ref,   h1->short_ref,   32, s, s1);
 856     copy_picture_range(h->long_ref,    h1->long_ref,    32, s, s1);
 857     copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);
 858
 859     h->last_slice_type = h1->last_slice_type;
 860
 861     if(!s->current_picture_ptr) return 0;
 862
 863     if(!s->dropable) {
 864         ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
 865         h->prev_poc_msb     = h->poc_msb;
 866         h->prev_poc_lsb     = h->poc_lsb;
 867     }
 868     h->prev_frame_num_offset= h->frame_num_offset;
 869     h->prev_frame_num       = h->frame_num;
 870     h->outputed_poc         = h->next_outputed_poc;
 871
 872     return 0;
 873 }
 874
 875 int ff_h264_frame_start(H264Context *h){
 876     MpegEncContext * const s = &h->s;
 877     int i;
 878     const int pixel_shift = h->pixel_shift;
 879     int thread_count = (s->avctx->active_thread_type & FF_THREAD_SLICE) ? s->avctx->thread_count : 1;
 880
 881     if(MPV_frame_start(s, s->avctx) < 0)
 882         return -1;
 883     ff_er_frame_start(s);
 884     /*
 885      * MPV_frame_start uses pict_type to derive key_frame.
 886      * This is incorrect for H.264; IDR markings must be used.
 887      * Zero here; IDR markings per slice in frame or fields are ORed in later.
 888      * See decode_nal_units().
 889      */
 890     s->current_picture_ptr->key_frame= 0;
 891     s->current_picture_ptr->mmco_reset= 0;
 892
 893     assert(s->linesize && s->uvlinesize);
 894
 895     for(i=0; i<16; i++){
 896         h->block_offset[i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->linesize*((scan8[i] - scan8[0])>>3);
 897         h->block_offset[24+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->linesize*((scan8[i] - scan8[0])>>3);
 898     }
 899     for(i=0; i<4; i++){
 900         h->block_offset[16+i]=
 901         h->block_offset[20+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3);
 902         h->block_offset[24+16+i]=
 903         h->block_offset[24+20+i]= (4*((scan8[i] - scan8[0])&7) << pixel_shift) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3);
 904     }
 905
 906     /* can't be in alloc_tables because linesize isn't known there.
 907      * FIXME: redo bipred weight to not require extra buffer? */
 908     for(i = 0; i < thread_count; i++)
 909         if(h->thread_context[i] && !h->thread_context[i]->s.obmc_scratchpad)
 910             h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize);
 911
 912     /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/
 913     memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table));
 914
 915 //    s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1;
 916
 917     // We mark the current picture as non-reference after allocating it, so
 918     // that if we break out due to an error it can be released automatically
 919     // in the next MPV_frame_start().
 920     // SVQ3 as well as most other codecs have only last/next/current and thus
 921     // get released even with set reference, besides SVQ3 and others do not
 922     // mark frames as reference later "naturally".
 923     if(s->codec_id != CODEC_ID_SVQ3)
 924         s->current_picture_ptr->reference= 0;
 925
 926     s->current_picture_ptr->field_poc[0]=
 927     s->current_picture_ptr->field_poc[1]= INT_MAX;
 928
 929     h->next_output_pic = NULL;
 930
 931     assert(s->current_picture_ptr->long_ref==0);
 932
 933     return 0;
 934 }
 935
 936 /**
 937   * Run setup operations that must be run after slice header decoding.
 938   * This includes finding the next displayed frame.
 939   *
 940   * @param h h264 master context
 941   * @param setup_finished enough NALs have been read that we can call
 942   * ff_thread_finish_setup()
 943   */
 944 static void decode_postinit(H264Context *h, int setup_finished){
 945     MpegEncContext * const s = &h->s;
 946     Picture *out = s->current_picture_ptr;
 947     Picture *cur = s->current_picture_ptr;
 948     int i, pics, out_of_order, out_idx;
 949
 950     s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
 951     s->current_picture_ptr->pict_type= s->pict_type;
 952
 953     if (h->next_output_pic) return;
 954
 955     if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) {
 956         //FIXME: if we have two PAFF fields in one packet, we can't start the next thread here.
 957         //If we have one field per packet, we can. The check in decode_nal_units() is not good enough
 958         //to find this yet, so we assume the worst for now.
 959         //if (setup_finished)
 960         //    ff_thread_finish_setup(s->avctx);
 961         return;
 962     }
 963
 964     cur->interlaced_frame = 0;
 965     cur->repeat_pict = 0;
 966
 967     /* Signal interlacing information externally. */
 968     /* Prioritize picture timing SEI information over used decoding process if it exists. */
 969
 970     if(h->sps.pic_struct_present_flag){
 971         switch (h->sei_pic_struct)
 972         {
 973         case SEI_PIC_STRUCT_FRAME:
 974             break;
 975         case SEI_PIC_STRUCT_TOP_FIELD:
 976         case SEI_PIC_STRUCT_BOTTOM_FIELD:
 977             cur->interlaced_frame = 1;
 978             break;
 979         case SEI_PIC_STRUCT_TOP_BOTTOM:
 980         case SEI_PIC_STRUCT_BOTTOM_TOP:
 981             if (FIELD_OR_MBAFF_PICTURE)
 982                 cur->interlaced_frame = 1;
 983             else
 984                 // try to flag soft telecine progressive
 985                 cur->interlaced_frame = h->prev_interlaced_frame;
 986             break;
 987         case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
 988         case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
 989             // Signal the possibility of telecined film externally (pic_struct 5,6)
 990             // From these hints, let the applications decide if they apply deinterlacing.
 991             cur->repeat_pict = 1;
 992             break;
 993         case SEI_PIC_STRUCT_FRAME_DOUBLING:
 994             // Force progressive here, as doubling interlaced frame is a bad idea.
 995             cur->repeat_pict = 2;
 996             break;
 997         case SEI_PIC_STRUCT_FRAME_TRIPLING:
 998             cur->repeat_pict = 4;
 999             break;
1000         }
1001
1002         if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP)
1003             cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0;
1004     }else{
1005         /* Derive interlacing flag from used decoding process. */
1006         cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE;
1007     }
1008     h->prev_interlaced_frame = cur->interlaced_frame;
1009
1010     if (cur->field_poc[0] != cur->field_poc[1]){
1011         /* Derive top_field_first from field pocs. */
1012         cur->top_field_first = cur->field_poc[0] < cur->field_poc[1];
1013     }else{
1014         if(cur->interlaced_frame || h->sps.pic_struct_present_flag){
1015             /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */
1016             if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM
1017               || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
1018                 cur->top_field_first = 1;
1019             else
1020                 cur->top_field_first = 0;
1021         }else{
1022             /* Most likely progressive */
1023             cur->top_field_first = 0;
1024         }
1025     }
1026
1027     //FIXME do something with unavailable reference frames
1028
1029     /* Sort B-frames into display order */
1030
1031     if(h->sps.bitstream_restriction_flag
1032        && s->avctx->has_b_frames < h->sps.num_reorder_frames){
1033         s->avctx->has_b_frames = h->sps.num_reorder_frames;
1034         s->low_delay = 0;
1035     }
1036
1037     if(   s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT
1038        && !h->sps.bitstream_restriction_flag){
1039         s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT;
1040         s->low_delay= 0;
1041     }
1042
1043     pics = 0;
1044     while(h->delayed_pic[pics]) pics++;
1045
1046     assert(pics <= MAX_DELAYED_PIC_COUNT);
1047
1048     h->delayed_pic[pics++] = cur;
1049     if(cur->reference == 0)
1050         cur->reference = DELAYED_PIC_REF;
1051
1052     out = h->delayed_pic[0];
1053     out_idx = 0;
1054     for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
1055         if(h->delayed_pic[i]->poc < out->poc){
1056             out = h->delayed_pic[i];
1057             out_idx = i;
1058         }
1059     if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset))
1060         h->next_outputed_poc= INT_MIN;
1061     out_of_order = out->poc < h->next_outputed_poc;
1062
1063     if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames)
1064         { }
1065     else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT)
1066        || (s->low_delay &&
1067         ((h->next_outputed_poc != INT_MIN && out->poc > h->next_outputed_poc + 2)
1068          || cur->pict_type == AV_PICTURE_TYPE_B)))
1069     {
1070         s->low_delay = 0;
1071         s->avctx->has_b_frames++;
1072     }
1073
1074     if(out_of_order || pics > s->avctx->has_b_frames){
1075         out->reference &= ~DELAYED_PIC_REF;
1076         out->owner2 = s; // for frame threading, the owner must be the second field's thread
1077                          // or else the first thread can release the picture and reuse it unsafely
1078         for(i=out_idx; h->delayed_pic[i]; i++)
1079             h->delayed_pic[i] = h->delayed_pic[i+1];
1080     }
1081     if(!out_of_order && pics > s->avctx->has_b_frames){
1082         h->next_output_pic = out;
1083         if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) {
1084             h->next_outputed_poc = INT_MIN;
1085         } else
1086             h->next_outputed_poc = out->poc;
1087     }else{
1088         av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");
1089     }
1090
1091     if (setup_finished)
1092         ff_thread_finish_setup(s->avctx);
1093 }
1094
1095 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){
1096     MpegEncContext * const s = &h->s;
1097     uint8_t *top_border;
1098     int top_idx = 1;
1099     const int pixel_shift = h->pixel_shift;
1100
1101     src_y  -=   linesize;
1102     src_cb -= uvlinesize;
1103     src_cr -= uvlinesize;
1104
1105     if(!simple && FRAME_MBAFF){
1106         if(s->mb_y&1){
1107             if(!MB_MBAFF){
1108                 top_border = h->top_borders[0][s->mb_x];
1109                 AV_COPY128(top_border, src_y + 15*linesize);
1110                 if (pixel_shift)
1111                     AV_COPY128(top_border+16, src_y+15*linesize+16);
1112                 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1113                     if (pixel_shift) {
1114                         AV_COPY128(top_border+32, src_cb+7*uvlinesize);
1115                         AV_COPY128(top_border+48, src_cr+7*uvlinesize);
1116                     } else {
1117                     AV_COPY64(top_border+16, src_cb+7*uvlinesize);
1118                     AV_COPY64(top_border+24, src_cr+7*uvlinesize);
1119                     }
1120                 }
1121             }
1122         }else if(MB_MBAFF){
1123             top_idx = 0;
1124         }else
1125             return;
1126     }
1127
1128     top_border = h->top_borders[top_idx][s->mb_x];
1129     // There are two lines saved, the line above the the top macroblock of a pair,
1130     // and the line above the bottom macroblock
1131     AV_COPY128(top_border, src_y + 16*linesize);
1132     if (pixel_shift)
1133         AV_COPY128(top_border+16, src_y+16*linesize+16);
1134
1135     if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1136         if (pixel_shift) {
1137             AV_COPY128(top_border+32, src_cb+8*uvlinesize);
1138             AV_COPY128(top_border+48, src_cr+8*uvlinesize);
1139         } else {
1140         AV_COPY64(top_border+16, src_cb+8*uvlinesize);
1141         AV_COPY64(top_border+24, src_cr+8*uvlinesize);
1142         }
1143     }
1144 }
1145
1146 static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
1147                                   uint8_t *src_cb, uint8_t *src_cr,
1148                                   int linesize, int uvlinesize,
1149                                   int xchg, int simple, int pixel_shift){
1150     MpegEncContext * const s = &h->s;
1151     int deblock_topleft;
1152     int deblock_top;
1153     int top_idx = 1;
1154     uint8_t *top_border_m1;
1155     uint8_t *top_border;
1156
1157     if(!simple && FRAME_MBAFF){
1158         if(s->mb_y&1){
1159             if(!MB_MBAFF)
1160                 return;
1161         }else{
1162             top_idx = MB_MBAFF ? 0 : 1;
1163         }
1164     }
1165
1166     if(h->deblocking_filter == 2) {
1167         deblock_topleft = h->slice_table[h->mb_xy - 1 - s->mb_stride] == h->slice_num;
1168         deblock_top     = h->top_type;
1169     } else {
1170         deblock_topleft = (s->mb_x > 0);
1171         deblock_top     = (s->mb_y > !!MB_FIELD);
1172     }
1173
1174     src_y  -=   linesize + 1 + pixel_shift;
1175     src_cb -= uvlinesize + 1 + pixel_shift;
1176     src_cr -= uvlinesize + 1 + pixel_shift;
1177
1178     top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
1179     top_border    = h->top_borders[top_idx][s->mb_x];
1180
1181 #define XCHG(a,b,xchg)\
1182     if (pixel_shift) {\
1183         if (xchg) {\
1184             AV_SWAP64(b+0,a+0);\
1185             AV_SWAP64(b+8,a+8);\
1186         } else {\
1187             AV_COPY128(b,a); \
1188         }\
1189     } else \
1190 if (xchg) AV_SWAP64(b,a);\
1191 else      AV_COPY64(b,a);
1192
1193     if(deblock_top){
1194         if(deblock_topleft){
1195             XCHG(top_border_m1 + (8 << pixel_shift), src_y - (7 << pixel_shift), 1);
1196         }
1197         XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
1198         XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
1199         if(s->mb_x+1 < s->mb_width){
1200             XCHG(h->top_borders[top_idx][s->mb_x+1], src_y + (17 << pixel_shift), 1);
1201         }
1202     }
1203     if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1204         if(deblock_top){
1205             if(deblock_topleft){
1206                 XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
1207                 XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
1208             }
1209             XCHG(top_border + (16 << pixel_shift), src_cb+1+pixel_shift, 1);
1210             XCHG(top_border + (24 << pixel_shift), src_cr+1+pixel_shift, 1);
1211         }
1212     }
1213 }
1214
1215 static av_always_inline int dctcoef_get(DCTELEM *mb, int high_bit_depth, int index) {
1216     if (high_bit_depth) {
1217         return AV_RN32A(((int32_t*)mb) + index);
1218     } else
1219         return AV_RN16A(mb + index);
1220 }
1221
1222 static av_always_inline void dctcoef_set(DCTELEM *mb, int high_bit_depth, int index, int value) {
1223     if (high_bit_depth) {
1224         AV_WN32A(((int32_t*)mb) + index, value);
1225     } else
1226         AV_WN16A(mb + index, value);
1227 }
1228
1229 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple, int pixel_shift){
1230     MpegEncContext * const s = &h->s;
1231     const int mb_x= s->mb_x;
1232     const int mb_y= s->mb_y;
1233     const int mb_xy= h->mb_xy;
1234     const int mb_type= s->current_picture.mb_type[mb_xy];
1235     uint8_t  *dest_y, *dest_cb, *dest_cr;
1236     int linesize, uvlinesize /*dct_offset*/;
1237     int i;
1238     int *block_offset = &h->block_offset[0];
1239     const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass);
1240     /* is_h264 should always be true if SVQ3 is disabled. */
1241     const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
1242     void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
1243     void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
1244
1245     dest_y  = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
1246     dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
1247     dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
1248
1249     s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + (64 << pixel_shift), s->linesize, 4);
1250     s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + (64 << pixel_shift), dest_cr - dest_cb, 2);
1251
1252     h->list_counts[mb_xy]= h->list_count;
1253
1254     if (!simple && MB_FIELD) {
1255         linesize   = h->mb_linesize   = s->linesize * 2;
1256         uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
1257         block_offset = &h->block_offset[24];
1258         if(mb_y&1){ //FIXME move out of this function?
1259             dest_y -= s->linesize*15;
1260             dest_cb-= s->uvlinesize*7;
1261             dest_cr-= s->uvlinesize*7;
1262         }
1263         if(FRAME_MBAFF) {
1264             int list;
1265             for(list=0; list<h->list_count; list++){
1266                 if(!USES_LIST(mb_type, list))
1267                     continue;
1268                 if(IS_16X16(mb_type)){
1269                     int8_t *ref = &h->ref_cache[list][scan8[0]];
1270                     fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1);
1271                 }else{
1272                     for(i=0; i<16; i+=4){
1273                         int ref = h->ref_cache[list][scan8[i]];
1274                         if(ref >= 0)
1275                             fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1);
1276                     }
1277                 }
1278             }
1279         }
1280     } else {
1281         linesize   = h->mb_linesize   = s->linesize;
1282         uvlinesize = h->mb_uvlinesize = s->uvlinesize;
1283 //        dct_offset = s->linesize * 16;
1284     }
1285
1286     if (!simple && IS_INTRA_PCM(mb_type)) {
1287         if (pixel_shift) {
1288             const int bit_depth = h->sps.bit_depth_luma;
1289             int j;
1290             GetBitContext gb;
1291             init_get_bits(&gb, (uint8_t*)h->mb, 384*bit_depth);
1292
1293             for (i = 0; i < 16; i++) {
1294                 uint16_t *tmp_y  = (uint16_t*)(dest_y  + i*linesize);
1295                 for (j = 0; j < 16; j++)
1296                     tmp_y[j] = get_bits(&gb, bit_depth);
1297             }
1298             for (i = 0; i < 8; i++) {
1299                 uint16_t *tmp_cb = (uint16_t*)(dest_cb + i*uvlinesize);
1300                 for (j = 0; j < 8; j++)
1301                     tmp_cb[j] = get_bits(&gb, bit_depth);
1302             }
1303             for (i = 0; i < 8; i++) {
1304                 uint16_t *tmp_cr = (uint16_t*)(dest_cr + i*uvlinesize);
1305                 for (j = 0; j < 8; j++)
1306                     tmp_cr[j] = get_bits(&gb, bit_depth);
1307             }
1308         } else {
1309         for (i=0; i<16; i++) {
1310             memcpy(dest_y + i*  linesize, h->mb       + i*8, 16);
1311         }
1312         for (i=0; i<8; i++) {
1313             memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
1314             memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
1315         }
1316         }
1317     } else {
1318         if(IS_INTRA(mb_type)){
1319             if(h->deblocking_filter)
1320                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple, pixel_shift);
1321
1322             if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1323                 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize);
1324                 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize);
1325             }
1326
1327             if(IS_INTRA4x4(mb_type)){
1328                 if(simple || !s->encoding){
1329                     if(IS_8x8DCT(mb_type)){
1330                         if(transform_bypass){
1331                             idct_dc_add =
1332                             idct_add    = s->dsp.add_pixels8;
1333                         }else{
1334                             idct_dc_add = h->h264dsp.h264_idct8_dc_add;
1335                             idct_add    = h->h264dsp.h264_idct8_add;
1336                         }
1337                         for(i=0; i<16; i+=4){
1338                             uint8_t * const ptr= dest_y + block_offset[i];
1339                             const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1340                             if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1341                                 h->hpc.pred8x8l_add[dir](ptr, h->mb + (i*16 << pixel_shift), linesize);
1342                             }else{
1343                                 const int nnz = h->non_zero_count_cache[ scan8[i] ];
1344                                 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000,
1345                                                             (h->topright_samples_available<<i)&0x4000, linesize);
1346                                 if(nnz){
1347                                     if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16))
1348                                         idct_dc_add(ptr, h->mb + (i*16 << pixel_shift), linesize);
1349                                     else
1350                                         idct_add   (ptr, h->mb + (i*16 << pixel_shift), linesize);
1351                                 }
1352                             }
1353                         }
1354                     }else{
1355                         if(transform_bypass){
1356                             idct_dc_add =
1357                             idct_add    = s->dsp.add_pixels4;
1358                         }else{
1359                             idct_dc_add = h->h264dsp.h264_idct_dc_add;
1360                             idct_add    = h->h264dsp.h264_idct_add;
1361                         }
1362                         for(i=0; i<16; i++){
1363                             uint8_t * const ptr= dest_y + block_offset[i];
1364                             const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ];
1365
1366                             if(transform_bypass && h->sps.profile_idc==244 && dir<=1){
1367                                 h->hpc.pred4x4_add[dir](ptr, h->mb + (i*16 << pixel_shift), linesize);
1368                             }else{
1369                                 uint8_t *topright;
1370                                 int nnz, tr;
1371                                 uint64_t tr_high;
1372                                 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){
1373                                     const int topright_avail= (h->topright_samples_available<<i)&0x8000;
1374                                     assert(mb_y || linesize <= block_offset[i]);
1375                                     if(!topright_avail){
1376                                         if (pixel_shift) {
1377                                             tr_high= ((uint16_t*)ptr)[3 - linesize/2]*0x0001000100010001ULL;
1378                                             topright= (uint8_t*) &tr_high;
1379                                         } else {
1380                                         tr= ptr[3 - linesize]*0x01010101;
1381                                         topright= (uint8_t*) &tr;
1382                                         }
1383                                     }else
1384                                         topright= ptr + (4 << pixel_shift) - linesize;
1385                                 }else
1386                                     topright= NULL;
1387
1388                                 h->hpc.pred4x4[ dir ](ptr, topright, linesize);
1389                                 nnz = h->non_zero_count_cache[ scan8[i] ];
1390                                 if(nnz){
1391                                     if(is_h264){
1392                                         if(nnz == 1 && dctcoef_get(h->mb, pixel_shift, i*16))
1393                                             idct_dc_add(ptr, h->mb + (i*16 << pixel_shift), linesize);
1394                                         else
1395                                             idct_add   (ptr, h->mb + (i*16<<pixel_shift), linesize);
1396                                     }
1397 #if CONFIG_SVQ3_DECODER
1398                                     else
1399                                         ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0);
1400 #endif
1401                                 }
1402                             }
1403                         }
1404                     }
1405                 }
1406             }else{
1407                 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize);
1408                 if(is_h264){
1409                     if(h->non_zero_count_cache[ scan8[LUMA_DC_BLOCK_INDEX] ]){
1410                         if(!transform_bypass)
1411                             h->h264dsp.h264_luma_dc_dequant_idct(h->mb, h->mb_luma_dc, h->dequant4_coeff[0][s->qscale][0]);
1412                         else{
1413                             static const uint8_t dc_mapping[16] = { 0*16, 1*16, 4*16, 5*16, 2*16, 3*16, 6*16, 7*16,
1414                                                                     8*16, 9*16,12*16,13*16,10*16,11*16,14*16,15*16};
1415                             for(i = 0; i < 16; i++)
1416                                 dctcoef_set(h->mb, pixel_shift, dc_mapping[i], dctcoef_get(h->mb_luma_dc, pixel_shift, i));
1417                         }
1418                     }
1419                 }
1420 #if CONFIG_SVQ3_DECODER
1421                 else
1422                     ff_svq3_luma_dc_dequant_idct_c(h->mb, h->mb_luma_dc, s->qscale);
1423 #endif
1424             }
1425             if(h->deblocking_filter)
1426                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple, pixel_shift);
1427         }else if(is_h264){
1428             ff_hl_motion(h, dest_y, dest_cb, dest_cr,
1429                       s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
1430                       s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
1431                       h->h264dsp.weight_h264_pixels_tab, h->h264dsp.biweight_h264_pixels_tab);
1432         }
1433
1434
1435         if(!IS_INTRA4x4(mb_type)){
1436             if(is_h264){
1437                 if(IS_INTRA16x16(mb_type)){
1438                     if(transform_bypass){
1439                         if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){
1440                             h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize);
1441                         }else{
1442                             for(i=0; i<16; i++){
1443                                 if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))
1444                                     s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + (i*16 << pixel_shift), linesize);
1445                             }
1446                         }
1447                     }else{
1448                          h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1449                     }
1450                 }else if(h->cbp&15){
1451                     if(transform_bypass){
1452                         const int di = IS_8x8DCT(mb_type) ? 4 : 1;
1453                         idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4;
1454                         for(i=0; i<16; i+=di){
1455                             if(h->non_zero_count_cache[ scan8[i] ]){
1456                                 idct_add(dest_y + block_offset[i], h->mb + (i*16 << pixel_shift), linesize);
1457                             }
1458                         }
1459                     }else{
1460                         if(IS_8x8DCT(mb_type)){
1461                             h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1462                         }else{
1463                             h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache);
1464                         }
1465                     }
1466                 }
1467             }
1468 #if CONFIG_SVQ3_DECODER
1469             else{
1470                 for(i=0; i<16; i++){
1471                     if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below
1472                         uint8_t * const ptr= dest_y + block_offset[i];
1473                         ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0);
1474                     }
1475                 }
1476             }
1477 #endif
1478         }
1479
1480         if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){
1481             uint8_t *dest[2] = {dest_cb, dest_cr};
1482             if(transform_bypass){
1483                 if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){
1484                     h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + (16*16 << pixel_shift), uvlinesize);
1485                     h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + (20*16 << pixel_shift), uvlinesize);
1486                 }else{
1487                     idct_add = s->dsp.add_pixels4;
1488                     for(i=16; i<16+8; i++){
1489                         if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))
1490                             idct_add   (dest[(i&4)>>2] + block_offset[i], h->mb + (i*16 << pixel_shift), uvlinesize);
1491                     }
1492                 }
1493             }else{
1494                 if(is_h264){
1495                     if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+0] ])
1496                         h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16*16 << pixel_shift)       , h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1497                     if(h->non_zero_count_cache[ scan8[CHROMA_DC_BLOCK_INDEX+1] ])
1498                         h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + ((16*16+4*16) << pixel_shift), h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1499                     h->h264dsp.h264_idct_add8(dest, block_offset,
1500                                               h->mb, uvlinesize,
1501                                               h->non_zero_count_cache);
1502                 }
1503 #if CONFIG_SVQ3_DECODER
1504                 else{
1505                     h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16     , h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
1506                     h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16+4*16, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
1507                     for(i=16; i<16+8; i++){
1508                         if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){
1509                             uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i];
1510                             ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
1511                         }
1512                     }
1513                 }
1514 #endif
1515             }
1516         }
1517     }
1518     if(h->cbp || IS_INTRA(mb_type))
1519         s->dsp.clear_blocks(h->mb);
1520 }
1521
1522 /**
1523  * Process a macroblock; this case avoids checks for expensive uncommon cases.
1524  */
1525 #define hl_decode_mb_simple(sh, bits) \
1526 static void hl_decode_mb_simple_ ## bits(H264Context *h){ \
1527     hl_decode_mb_internal(h, 1, sh); \
1528 }
1529 hl_decode_mb_simple(0, 8);
1530 hl_decode_mb_simple(1, 16);
1531
1532 /**
1533  * Process a macroblock; this handles edge cases, such as interlacing.
1534  */
1535 static void av_noinline hl_decode_mb_complex(H264Context *h){
1536     hl_decode_mb_internal(h, 0, h->pixel_shift);
1537 }
1538
1539 void ff_h264_hl_decode_mb(H264Context *h){
1540     MpegEncContext * const s = &h->s;
1541     const int mb_xy= h->mb_xy;
1542     const int mb_type= s->current_picture.mb_type[mb_xy];
1543     int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0;
1544
1545     if (is_complex) {
1546         hl_decode_mb_complex(h);
1547     } else if (h->pixel_shift) {
1548         hl_decode_mb_simple_16(h);
1549     } else
1550         hl_decode_mb_simple_8(h);
1551 }
1552
1553 static int pred_weight_table(H264Context *h){
1554     MpegEncContext * const s = &h->s;
1555     int list, i;
1556     int luma_def, chroma_def;
1557
1558     h->use_weight= 0;
1559     h->use_weight_chroma= 0;
1560     h->luma_log2_weight_denom= get_ue_golomb(&s->gb);
1561     if(CHROMA)
1562         h->chroma_log2_weight_denom= get_ue_golomb(&s->gb);
1563     luma_def = 1<<h->luma_log2_weight_denom;
1564     chroma_def = 1<<h->chroma_log2_weight_denom;
1565
1566     for(list=0; list<2; list++){
1567         h->luma_weight_flag[list]   = 0;
1568         h->chroma_weight_flag[list] = 0;
1569         for(i=0; i<h->ref_count[list]; i++){
1570             int luma_weight_flag, chroma_weight_flag;
1571
1572             luma_weight_flag= get_bits1(&s->gb);
1573             if(luma_weight_flag){
1574                 h->luma_weight[i][list][0]= get_se_golomb(&s->gb);
1575                 h->luma_weight[i][list][1]= get_se_golomb(&s->gb);
1576                 if(   h->luma_weight[i][list][0] != luma_def
1577                    || h->luma_weight[i][list][1] != 0) {
1578                     h->use_weight= 1;
1579                     h->luma_weight_flag[list]= 1;
1580                 }
1581             }else{
1582                 h->luma_weight[i][list][0]= luma_def;
1583                 h->luma_weight[i][list][1]= 0;
1584             }
1585
1586             if(CHROMA){
1587                 chroma_weight_flag= get_bits1(&s->gb);
1588                 if(chroma_weight_flag){
1589                     int j;
1590                     for(j=0; j<2; j++){
1591                         h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb);
1592                         h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb);
1593                         if(   h->chroma_weight[i][list][j][0] != chroma_def
1594                            || h->chroma_weight[i][list][j][1] != 0) {
1595                             h->use_weight_chroma= 1;
1596                             h->chroma_weight_flag[list]= 1;
1597                         }
1598                     }
1599                 }else{
1600                     int j;
1601                     for(j=0; j<2; j++){
1602                         h->chroma_weight[i][list][j][0]= chroma_def;
1603                         h->chroma_weight[i][list][j][1]= 0;
1604                     }
1605                 }
1606             }
1607         }
1608         if(h->slice_type_nos != AV_PICTURE_TYPE_B) break;
1609     }
1610     h->use_weight= h->use_weight || h->use_weight_chroma;
1611     return 0;
1612 }
1613
1614 /**
1615  * Initialize implicit_weight table.
1616  * @param field  0/1 initialize the weight for interlaced MBAFF
1617  *                -1 initializes the rest
1618  */
1619 static void implicit_weight_table(H264Context *h, int field){
1620     MpegEncContext * const s = &h->s;
1621     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
1622
1623     for (i = 0; i < 2; i++) {
1624         h->luma_weight_flag[i]   = 0;
1625         h->chroma_weight_flag[i] = 0;
1626     }
1627
1628     if(field < 0){
1629         cur_poc = s->current_picture_ptr->poc;
1630     if(   h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF
1631        && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){
1632         h->use_weight= 0;
1633         h->use_weight_chroma= 0;
1634         return;
1635     }
1636         ref_start= 0;
1637         ref_count0= h->ref_count[0];
1638         ref_count1= h->ref_count[1];
1639     }else{
1640         cur_poc = s->current_picture_ptr->field_poc[field];
1641         ref_start= 16;
1642         ref_count0= 16+2*h->ref_count[0];
1643         ref_count1= 16+2*h->ref_count[1];
1644     }
1645
1646     h->use_weight= 2;
1647     h->use_weight_chroma= 2;
1648     h->luma_log2_weight_denom= 5;
1649     h->chroma_log2_weight_denom= 5;
1650
1651     for(ref0=ref_start; ref0 < ref_count0; ref0++){
1652         int poc0 = h->ref_list[0][ref0].poc;
1653         for(ref1=ref_start; ref1 < ref_count1; ref1++){
1654             int poc1 = h->ref_list[1][ref1].poc;
1655             int td = av_clip(poc1 - poc0, -128, 127);
1656             int w= 32;
1657             if(td){
1658                 int tb = av_clip(cur_poc - poc0, -128, 127);
1659                 int tx = (16384 + (FFABS(td) >> 1)) / td;
1660                 int dist_scale_factor = (tb*tx + 32) >> 8;
1661                 if(dist_scale_factor >= -64 && dist_scale_factor <= 128)
1662                     w = 64 - dist_scale_factor;
1663             }
1664             if(field<0){
1665                 h->implicit_weight[ref0][ref1][0]=
1666                 h->implicit_weight[ref0][ref1][1]= w;
1667             }else{
1668                 h->implicit_weight[ref0][ref1][field]=w;
1669             }
1670         }
1671     }
1672 }
1673
1674 /**
1675  * instantaneous decoder refresh.
1676  */
1677 static void idr(H264Context *h){
1678     ff_h264_remove_all_refs(h);
1679     h->prev_frame_num= 0;
1680     h->prev_frame_num_offset= 0;
1681     h->prev_poc_msb=
1682     h->prev_poc_lsb= 0;
1683 }
1684
1685 /* forget old pics after a seek */
1686 static void flush_dpb(AVCodecContext *avctx){
1687     H264Context *h= avctx->priv_data;
1688     int i;
1689     for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
1690         if(h->delayed_pic[i])
1691             h->delayed_pic[i]->reference= 0;
1692         h->delayed_pic[i]= NULL;
1693     }
1694     h->outputed_poc=h->next_outputed_poc= INT_MIN;
1695     h->prev_interlaced_frame = 1;
1696     idr(h);
1697     if(h->s.current_picture_ptr)
1698         h->s.current_picture_ptr->reference= 0;
1699     h->s.first_field= 0;
1700     ff_h264_reset_sei(h);
1701     ff_mpeg_flush(avctx);
1702 }
1703
1704 static int init_poc(H264Context *h){
1705     MpegEncContext * const s = &h->s;
1706     const int max_frame_num= 1<<h->sps.log2_max_frame_num;
1707     int field_poc[2];
1708     Picture *cur = s->current_picture_ptr;
1709
1710     h->frame_num_offset= h->prev_frame_num_offset;
1711     if(h->frame_num < h->prev_frame_num)
1712         h->frame_num_offset += max_frame_num;
1713
1714     if(h->sps.poc_type==0){
1715         const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb;
1716
1717         if     (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2)
1718             h->poc_msb = h->prev_poc_msb + max_poc_lsb;
1719         else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2)
1720             h->poc_msb = h->prev_poc_msb - max_poc_lsb;
1721         else
1722             h->poc_msb = h->prev_poc_msb;
1723 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb);
1724         field_poc[0] =
1725         field_poc[1] = h->poc_msb + h->poc_lsb;
1726         if(s->picture_structure == PICT_FRAME)
1727             field_poc[1] += h->delta_poc_bottom;
1728     }else if(h->sps.poc_type==1){
1729         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
1730         int i;
1731
1732         if(h->sps.poc_cycle_length != 0)
1733             abs_frame_num = h->frame_num_offset + h->frame_num;
1734         else
1735             abs_frame_num = 0;
1736
1737         if(h->nal_ref_idc==0 && abs_frame_num > 0)
1738             abs_frame_num--;
1739
1740         expected_delta_per_poc_cycle = 0;
1741         for(i=0; i < h->sps.poc_cycle_length; i++)
1742             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse
1743
1744         if(abs_frame_num > 0){
1745             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
1746             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
1747
1748             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
1749             for(i = 0; i <= frame_num_in_poc_cycle; i++)
1750                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ];
1751         } else
1752             expectedpoc = 0;
1753
1754         if(h->nal_ref_idc == 0)
1755             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
1756
1757         field_poc[0] = expectedpoc + h->delta_poc[0];
1758         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
1759
1760         if(s->picture_structure == PICT_FRAME)
1761             field_poc[1] += h->delta_poc[1];
1762     }else{
1763         int poc= 2*(h->frame_num_offset + h->frame_num);
1764
1765         if(!h->nal_ref_idc)
1766             poc--;
1767
1768         field_poc[0]= poc;
1769         field_poc[1]= poc;
1770     }
1771
1772     if(s->picture_structure != PICT_BOTTOM_FIELD)
1773         s->current_picture_ptr->field_poc[0]= field_poc[0];
1774     if(s->picture_structure != PICT_TOP_FIELD)
1775         s->current_picture_ptr->field_poc[1]= field_poc[1];
1776     cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]);
1777
1778     return 0;
1779 }
1780
1781
1782 /**
1783  * initialize scan tables
1784  */
1785 static void init_scan_tables(H264Context *h){
1786     int i;
1787     for(i=0; i<16; i++){
1788 #define T(x) (x>>2) | ((x<<2) & 0xF)
1789         h->zigzag_scan[i] = T(zigzag_scan[i]);
1790         h-> field_scan[i] = T( field_scan[i]);
1791 #undef T
1792     }
1793     for(i=0; i<64; i++){
1794 #define T(x) (x>>3) | ((x&7)<<3)
1795         h->zigzag_scan8x8[i]       = T(ff_zigzag_direct[i]);
1796         h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]);
1797         h->field_scan8x8[i]        = T(field_scan8x8[i]);
1798         h->field_scan8x8_cavlc[i]  = T(field_scan8x8_cavlc[i]);
1799 #undef T
1800     }
1801     if(h->sps.transform_bypass){ //FIXME same ugly
1802         h->zigzag_scan_q0          = zigzag_scan;
1803         h->zigzag_scan8x8_q0       = ff_zigzag_direct;
1804         h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
1805         h->field_scan_q0           = field_scan;
1806         h->field_scan8x8_q0        = field_scan8x8;
1807         h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
1808     }else{
1809         h->zigzag_scan_q0          = h->zigzag_scan;
1810         h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
1811         h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
1812         h->field_scan_q0           = h->field_scan;
1813         h->field_scan8x8_q0        = h->field_scan8x8;
1814         h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
1815     }
1816 }
1817
1818 static void field_end(H264Context *h, int in_setup){
1819     MpegEncContext * const s = &h->s;
1820     AVCodecContext * const avctx= s->avctx;
1821     s->mb_y= 0;
1822
1823     if (!in_setup && !s->dropable)
1824         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, (16*s->mb_height >> FIELD_PICTURE) - 1,
1825                                  s->picture_structure==PICT_BOTTOM_FIELD);
1826
1827     if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1828         ff_vdpau_h264_set_reference_frames(s);
1829
1830     if(in_setup || !(avctx->active_thread_type&FF_THREAD_FRAME)){
1831         if(!s->dropable) {
1832             ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
1833             h->prev_poc_msb= h->poc_msb;
1834             h->prev_poc_lsb= h->poc_lsb;
1835         }
1836         h->prev_frame_num_offset= h->frame_num_offset;
1837         h->prev_frame_num= h->frame_num;
1838         h->outputed_poc = h->next_outputed_poc;
1839     }
1840
1841     if (avctx->hwaccel) {
1842         if (avctx->hwaccel->end_frame(avctx) < 0)
1843             av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n");
1844     }
1845
1846     if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1847         ff_vdpau_h264_picture_complete(s);
1848
1849     /*
1850      * FIXME: Error handling code does not seem to support interlaced
1851      * when slices span multiple rows
1852      * The ff_er_add_slice calls don't work right for bottom
1853      * fields; they cause massive erroneous error concealing
1854      * Error marking covers both fields (top and bottom).
1855      * This causes a mismatched s->error_count
1856      * and a bad error table. Further, the error count goes to
1857      * INT_MAX when called for bottom field, because mb_y is
1858      * past end by one (callers fault) and resync_mb_y != 0
1859      * causes problems for the first MB line, too.
1860      */
1861     if (!FIELD_PICTURE)
1862         ff_er_frame_end(s);
1863
1864     MPV_frame_end(s);
1865
1866     h->current_slice=0;
1867 }
1868
1869 /**
1870  * Replicate H264 "master" context to thread contexts.
1871  */
1872 static void clone_slice(H264Context *dst, H264Context *src)
1873 {
1874     memcpy(dst->block_offset,     src->block_offset, sizeof(dst->block_offset));
1875     dst->s.current_picture_ptr  = src->s.current_picture_ptr;
1876     dst->s.current_picture      = src->s.current_picture;
1877     dst->s.linesize             = src->s.linesize;
1878     dst->s.uvlinesize           = src->s.uvlinesize;
1879     dst->s.first_field          = src->s.first_field;
1880
1881     dst->prev_poc_msb           = src->prev_poc_msb;
1882     dst->prev_poc_lsb           = src->prev_poc_lsb;
1883     dst->prev_frame_num_offset  = src->prev_frame_num_offset;
1884     dst->prev_frame_num         = src->prev_frame_num;
1885     dst->short_ref_count        = src->short_ref_count;
1886
1887     memcpy(dst->short_ref,        src->short_ref,        sizeof(dst->short_ref));
1888     memcpy(dst->long_ref,         src->long_ref,         sizeof(dst->long_ref));
1889     memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list));
1890     memcpy(dst->ref_list,         src->ref_list,         sizeof(dst->ref_list));
1891
1892     memcpy(dst->dequant4_coeff,   src->dequant4_coeff,   sizeof(src->dequant4_coeff));
1893     memcpy(dst->dequant8_coeff,   src->dequant8_coeff,   sizeof(src->dequant8_coeff));
1894 }
1895
1896 /**
1897  * computes profile from profile_idc and constraint_set?_flags
1898  *
1899  * @param sps SPS
1900  *
1901  * @return profile as defined by FF_PROFILE_H264_*
1902  */
1903 int ff_h264_get_profile(SPS *sps)
1904 {
1905     int profile = sps->profile_idc;
1906
1907     switch(sps->profile_idc) {
1908     case FF_PROFILE_H264_BASELINE:
1909         // constraint_set1_flag set to 1
1910         profile |= (sps->constraint_set_flags & 1<<1) ? FF_PROFILE_H264_CONSTRAINED : 0;
1911         break;
1912     case FF_PROFILE_H264_HIGH_10:
1913     case FF_PROFILE_H264_HIGH_422:
1914     case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
1915         // constraint_set3_flag set to 1
1916         profile |= (sps->constraint_set_flags & 1<<3) ? FF_PROFILE_H264_INTRA : 0;
1917         break;
1918     }
1919
1920     return profile;
1921 }
1922
1923 /**
1924  * decodes a slice header.
1925  * This will also call MPV_common_init() and frame_start() as needed.
1926  *
1927  * @param h h264context
1928  * @param h0 h264 master context (differs from 'h' when doing sliced based parallel decoding)
1929  *
1930  * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
1931  */
1932 static int decode_slice_header(H264Context *h, H264Context *h0){
1933     MpegEncContext * const s = &h->s;
1934     MpegEncContext * const s0 = &h0->s;
1935     unsigned int first_mb_in_slice;
1936     unsigned int pps_id;
1937     int num_ref_idx_active_override_flag;
1938     unsigned int slice_type, tmp, i, j;
1939     int default_ref_list_done = 0;
1940     int last_pic_structure;
1941
1942     s->dropable= h->nal_ref_idc == 0;
1943
1944     if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){
1945         s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab;
1946         s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab;
1947     }else{
1948         s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab;
1949         s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab;
1950     }
1951
1952     first_mb_in_slice= get_ue_golomb(&s->gb);
1953
1954     if(first_mb_in_slice == 0){ //FIXME better field boundary detection
1955         if(h0->current_slice && FIELD_PICTURE){
1956             field_end(h, 1);
1957         }
1958
1959         h0->current_slice = 0;
1960         if (!s0->first_field)
1961             s->current_picture_ptr= NULL;
1962     }
1963
1964     slice_type= get_ue_golomb_31(&s->gb);
1965     if(slice_type > 9){
1966         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);
1967         return -1;
1968     }
1969     if(slice_type > 4){
1970         slice_type -= 5;
1971         h->slice_type_fixed=1;
1972     }else
1973         h->slice_type_fixed=0;
1974
1975     slice_type= golomb_to_pict_type[ slice_type ];
1976     if (slice_type == AV_PICTURE_TYPE_I
1977         || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) {
1978         default_ref_list_done = 1;
1979     }
1980     h->slice_type= slice_type;
1981     h->slice_type_nos= slice_type & 3;
1982
1983     s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though
1984
1985     pps_id= get_ue_golomb(&s->gb);
1986     if(pps_id>=MAX_PPS_COUNT){
1987         av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
1988         return -1;
1989     }
1990     if(!h0->pps_buffers[pps_id]) {
1991         av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id);
1992         return -1;
1993     }
1994     h->pps= *h0->pps_buffers[pps_id];
1995
1996     if(!h0->sps_buffers[h->pps.sps_id]) {
1997         av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id);
1998         return -1;
1999     }
2000     h->sps = *h0->sps_buffers[h->pps.sps_id];
2001
2002     s->avctx->profile = ff_h264_get_profile(&h->sps);
2003     s->avctx->level   = h->sps.level_idc;
2004     s->avctx->refs    = h->sps.ref_frame_count;
2005
2006     if(h == h0 && h->dequant_coeff_pps != pps_id){
2007         h->dequant_coeff_pps = pps_id;
2008         init_dequant_tables(h);
2009     }
2010
2011     s->mb_width= h->sps.mb_width;
2012     s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
2013
2014     h->b_stride=  s->mb_width*4;
2015
2016     s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7);
2017     if(h->sps.frame_mbs_only_flag)
2018         s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7);
2019     else
2020         s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 7);
2021
2022     if (s->context_initialized
2023         && (   s->width != s->avctx->width || s->height != s->avctx->height
2024             || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
2025         if(h != h0) {
2026             av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);
2027             return -1;   // width / height changed during parallelized decoding
2028         }
2029         free_tables(h, 0);
2030         flush_dpb(s->avctx);
2031         MPV_common_end(s);
2032     }
2033     if (!s->context_initialized) {
2034         if(h != h0){
2035             av_log(h->s.avctx, AV_LOG_ERROR, "we cant (re-)initialize context during parallel decoding\n");
2036             return -1;
2037         }
2038
2039         avcodec_set_dimensions(s->avctx, s->width, s->height);
2040         s->avctx->sample_aspect_ratio= h->sps.sar;
2041         av_assert0(s->avctx->sample_aspect_ratio.den);
2042
2043         h->s.avctx->coded_width = 16*s->mb_width;
2044         h->s.avctx->coded_height = 16*s->mb_height;
2045
2046         if(h->sps.video_signal_type_present_flag){
2047             s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
2048             if(h->sps.colour_description_present_flag){
2049                 s->avctx->color_primaries = h->sps.color_primaries;
2050                 s->avctx->color_trc       = h->sps.color_trc;
2051                 s->avctx->colorspace      = h->sps.colorspace;
2052             }
2053         }
2054
2055         if(h->sps.timing_info_present_flag){
2056             int64_t den= h->sps.time_scale;
2057             if(h->x264_build < 44U)
2058                 den *= 2;
2059             av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
2060                       h->sps.num_units_in_tick, den, 1<<30);
2061         }
2062
2063         switch (h->sps.bit_depth_luma) {
2064             case 9 :
2065                 s->avctx->pix_fmt = PIX_FMT_YUV420P9;
2066                 break;
2067             case 10 :
2068                 s->avctx->pix_fmt = PIX_FMT_YUV420P10;
2069                 break;
2070             default:
2071         s->avctx->pix_fmt = s->avctx->get_format(s->avctx,
2072                                                  s->avctx->codec->pix_fmts ?
2073                                                  s->avctx->codec->pix_fmts :
2074                                                  s->avctx->color_range == AVCOL_RANGE_JPEG ?
2075                                                  hwaccel_pixfmt_list_h264_jpeg_420 :
2076                                                  ff_hwaccel_pixfmt_list_420);
2077         }
2078
2079         s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
2080
2081         if (MPV_common_init(s) < 0){
2082             av_log(h->s.avctx, AV_LOG_ERROR, "MPV_common_init() failed\n");
2083             return -1;
2084         }
2085         s->first_field = 0;
2086         h->prev_interlaced_frame = 1;
2087
2088         init_scan_tables(h);
2089         ff_h264_alloc_tables(h);
2090
2091         if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_SLICE)) {
2092             if (context_init(h) < 0){
2093                 av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed\n");
2094                 return -1;
2095             }
2096         } else {
2097             for(i = 1; i < s->avctx->thread_count; i++) {
2098                 H264Context *c;
2099                 c = h->thread_context[i] = av_malloc(sizeof(H264Context));
2100                 memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
2101                 memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
2102                 c->h264dsp = h->h264dsp;
2103                 c->sps = h->sps;
2104                 c->pps = h->pps;
2105                 c->pixel_shift = h->pixel_shift;
2106                 init_scan_tables(c);
2107                 clone_tables(c, h, i);
2108             }
2109
2110             for(i = 0; i < s->avctx->thread_count; i++)
2111                 if(context_init(h->thread_context[i]) < 0){
2112                     av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed\n");
2113                     return -1;
2114                 }
2115         }
2116     }
2117
2118     h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num);
2119
2120     h->mb_mbaff = 0;
2121     h->mb_aff_frame = 0;
2122     last_pic_structure = s0->picture_structure;
2123     if(h->sps.frame_mbs_only_flag){
2124         s->picture_structure= PICT_FRAME;
2125     }else{
2126         if(get_bits1(&s->gb)) { //field_pic_flag
2127             s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
2128         } else {
2129             s->picture_structure= PICT_FRAME;
2130             h->mb_aff_frame = h->sps.mb_aff;
2131         }
2132     }
2133     h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME;
2134
2135     if(h0->current_slice == 0){
2136         if(h->frame_num != h->prev_frame_num &&
2137           (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num) < (h->frame_num - h->sps.ref_frame_count))
2138             h->prev_frame_num = h->frame_num - h->sps.ref_frame_count - 1;
2139
2140         while(h->frame_num !=  h->prev_frame_num &&
2141               h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){
2142             Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
2143             av_log(h->s.avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num);
2144             if (ff_h264_frame_start(h) < 0)
2145                 return -1;
2146             h->prev_frame_num++;
2147             h->prev_frame_num %= 1<<h->sps.log2_max_frame_num;
2148             s->current_picture_ptr->frame_num= h->prev_frame_num;
2149             ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 0);
2150             ff_thread_report_progress((AVFrame*)s->current_picture_ptr, INT_MAX, 1);
2151             ff_generate_sliding_window_mmcos(h);
2152             ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
2153             /* Error concealment: if a ref is missing, copy the previous ref in its place.
2154              * FIXME: avoiding a memcpy would be nice, but ref handling makes many assumptions
2155              * about there being no actual duplicates.
2156              * FIXME: this doesn't copy padding for out-of-frame motion vectors.  Given we're
2157              * concealing a lost frame, this probably isn't noticable by comparison, but it should
2158              * be fixed. */
2159             if (h->short_ref_count) {
2160                 if (prev) {
2161                     av_image_copy(h->short_ref[0]->data, h->short_ref[0]->linesize,
2162                                   (const uint8_t**)prev->data, prev->linesize,
2163                                   s->avctx->pix_fmt, s->mb_width*16, s->mb_height*16);
2164                     h->short_ref[0]->poc = prev->poc+2;
2165                 }
2166                 h->short_ref[0]->frame_num = h->prev_frame_num;
2167             }
2168         }
2169
2170         /* See if we have a decoded first field looking for a pair... */
2171         if (s0->first_field) {
2172             assert(s0->current_picture_ptr);
2173             assert(s0->current_picture_ptr->data[0]);
2174             assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF);
2175
2176             /* figure out if we have a complementary field pair */
2177             if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) {
2178                 /*
2179                  * Previous field is unmatched. Don't display it, but let it
2180                  * remain for reference if marked as such.
2181                  */
2182                 s0->current_picture_ptr = NULL;
2183                 s0->first_field = FIELD_PICTURE;
2184
2185             } else {
2186                 if (h->nal_ref_idc &&
2187                         s0->current_picture_ptr->reference &&
2188                         s0->current_picture_ptr->frame_num != h->frame_num) {
2189                     /*
2190                      * This and previous field were reference, but had
2191                      * different frame_nums. Consider this field first in
2192                      * pair. Throw away previous field except for reference
2193                      * purposes.
2194                      */
2195                     s0->first_field = 1;
2196                     s0->current_picture_ptr = NULL;
2197
2198                 } else {
2199                     /* Second field in complementary pair */
2200                     s0->first_field = 0;
2201                 }
2202             }
2203
2204         } else {
2205             /* Frame or first field in a potentially complementary pair */
2206             assert(!s0->current_picture_ptr);
2207             s0->first_field = FIELD_PICTURE;
2208         }
2209
2210         if(!FIELD_PICTURE || s0->first_field) {
2211             if (ff_h264_frame_start(h) < 0) {
2212                 s0->first_field = 0;
2213                 return -1;
2214             }
2215         } else {
2216             ff_release_unused_pictures(s, 0);
2217         }
2218     }
2219     if(h != h0)
2220         clone_slice(h, h0);
2221
2222     s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup
2223
2224     assert(s->mb_num == s->mb_width * s->mb_height);
2225     if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num ||
2226        first_mb_in_slice                    >= s->mb_num){
2227         av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
2228         return -1;
2229     }
2230     s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width;
2231     s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE;
2232     if (s->picture_structure == PICT_BOTTOM_FIELD)
2233         s->resync_mb_y = s->mb_y = s->mb_y + 1;
2234     assert(s->mb_y < s->mb_height);
2235
2236     if(s->picture_structure==PICT_FRAME){
2237         h->curr_pic_num=   h->frame_num;
2238         h->max_pic_num= 1<< h->sps.log2_max_frame_num;
2239     }else{
2240         h->curr_pic_num= 2*h->frame_num + 1;
2241         h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1);
2242     }
2243
2244     if(h->nal_unit_type == NAL_IDR_SLICE){
2245         get_ue_golomb(&s->gb); /* idr_pic_id */
2246     }
2247
2248     if(h->sps.poc_type==0){
2249         h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb);
2250
2251         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){
2252             h->delta_poc_bottom= get_se_golomb(&s->gb);
2253         }
2254     }
2255
2256     if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){
2257         h->delta_poc[0]= get_se_golomb(&s->gb);
2258
2259         if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME)
2260             h->delta_poc[1]= get_se_golomb(&s->gb);
2261     }
2262
2263     init_poc(h);
2264
2265     if(h->pps.redundant_pic_cnt_present){
2266         h->redundant_pic_count= get_ue_golomb(&s->gb);
2267     }
2268
2269     //set defaults, might be overridden a few lines later
2270     h->ref_count[0]= h->pps.ref_count[0];
2271     h->ref_count[1]= h->pps.ref_count[1];
2272
2273     if(h->slice_type_nos != AV_PICTURE_TYPE_I){
2274         if(h->slice_type_nos == AV_PICTURE_TYPE_B){
2275             h->direct_spatial_mv_pred= get_bits1(&s->gb);
2276         }
2277         num_ref_idx_active_override_flag= get_bits1(&s->gb);
2278
2279         if(num_ref_idx_active_override_flag){
2280             h->ref_count[0]= get_ue_golomb(&s->gb) + 1;
2281             if(h->slice_type_nos==AV_PICTURE_TYPE_B)
2282                 h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
2283
2284             if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
2285                 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
2286                 h->ref_count[0]= h->ref_count[1]= 1;
2287                 return -1;
2288             }
2289         }
2290         if(h->slice_type_nos == AV_PICTURE_TYPE_B)
2291             h->list_count= 2;
2292         else
2293             h->list_count= 1;
2294     }else
2295         h->list_count= 0;
2296
2297     if(!default_ref_list_done){
2298         ff_h264_fill_default_ref_list(h);
2299     }
2300
2301     if(h->slice_type_nos!=AV_PICTURE_TYPE_I && ff_h264_decode_ref_pic_list_reordering(h) < 0)
2302         return -1;
2303
2304     if(h->slice_type_nos!=AV_PICTURE_TYPE_I){
2305         s->last_picture_ptr= &h->ref_list[0][0];
2306         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
2307     }
2308     if(h->slice_type_nos==AV_PICTURE_TYPE_B){
2309         s->next_picture_ptr= &h->ref_list[1][0];
2310         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
2311     }
2312
2313     if(   (h->pps.weighted_pred          && h->slice_type_nos == AV_PICTURE_TYPE_P )
2314        ||  (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== AV_PICTURE_TYPE_B ) )
2315         pred_weight_table(h);
2316     else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){
2317         implicit_weight_table(h, -1);
2318     }else {
2319         h->use_weight = 0;
2320         for (i = 0; i < 2; i++) {
2321             h->luma_weight_flag[i]   = 0;
2322             h->chroma_weight_flag[i] = 0;
2323         }
2324     }
2325
2326     if(h->nal_ref_idc)
2327         ff_h264_decode_ref_pic_marking(h0, &s->gb);
2328
2329     if(FRAME_MBAFF){
2330         ff_h264_fill_mbaff_ref_list(h);
2331
2332         if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== AV_PICTURE_TYPE_B){
2333             implicit_weight_table(h, 0);
2334             implicit_weight_table(h, 1);
2335         }
2336     }
2337
2338     if(h->slice_type_nos==AV_PICTURE_TYPE_B && !h->direct_spatial_mv_pred)
2339         ff_h264_direct_dist_scale_factor(h);
2340     ff_h264_direct_ref_list_init(h);
2341
2342     if( h->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac ){
2343         tmp = get_ue_golomb_31(&s->gb);
2344         if(tmp > 2){
2345             av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n");
2346             return -1;
2347         }
2348         h->cabac_init_idc= tmp;
2349     }
2350
2351     h->last_qscale_diff = 0;
2352     tmp = h->pps.init_qp + get_se_golomb(&s->gb);
2353     if(tmp>51+6*(h->sps.bit_depth_luma-8)){
2354         av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
2355         return -1;
2356     }
2357     s->qscale= tmp;
2358     h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2359     h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
2360     //FIXME qscale / qp ... stuff
2361     if(h->slice_type == AV_PICTURE_TYPE_SP){
2362         get_bits1(&s->gb); /* sp_for_switch_flag */
2363     }
2364     if(h->slice_type==AV_PICTURE_TYPE_SP || h->slice_type == AV_PICTURE_TYPE_SI){
2365         get_se_golomb(&s->gb); /* slice_qs_delta */
2366     }
2367
2368     h->deblocking_filter = 1;
2369     h->slice_alpha_c0_offset = 52;
2370     h->slice_beta_offset = 52;
2371     if( h->pps.deblocking_filter_parameters_present ) {
2372         tmp= get_ue_golomb_31(&s->gb);
2373         if(tmp > 2){
2374             av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp);
2375             return -1;
2376         }
2377         h->deblocking_filter= tmp;
2378         if(h->deblocking_filter < 2)
2379             h->deblocking_filter^= 1; // 1<->0
2380
2381         if( h->deblocking_filter ) {
2382             h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1;
2383             h->slice_beta_offset     += get_se_golomb(&s->gb) << 1;
2384             if(   h->slice_alpha_c0_offset > 104U
2385                || h->slice_beta_offset     > 104U){
2386                 av_log(s->avctx, AV_LOG_ERROR, "deblocking filter parameters %d %d out of range\n", h->slice_alpha_c0_offset, h->slice_beta_offset);
2387                 return -1;
2388             }
2389         }
2390     }
2391
2392     if(   s->avctx->skip_loop_filter >= AVDISCARD_ALL
2393        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != AV_PICTURE_TYPE_I)
2394        ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR  && h->slice_type_nos == AV_PICTURE_TYPE_B)
2395        ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0))
2396         h->deblocking_filter= 0;
2397
2398     if(h->deblocking_filter == 1 && h0->max_contexts > 1) {
2399         if(s->avctx->flags2 & CODEC_FLAG2_FAST) {
2400             /* Cheat slightly for speed:
2401                Do not bother to deblock across slices. */
2402             h->deblocking_filter = 2;
2403         } else {
2404             h0->max_contexts = 1;
2405             if(!h0->single_decode_warning) {
2406                 av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n");
2407                 h0->single_decode_warning = 1;
2408             }
2409             if(h != h0){
2410                 av_log(h->s.avctx, AV_LOG_ERROR, "deblocking switched inside frame\n");
2411                 return 1;
2412             }
2413         }
2414     }
2415     h->qp_thresh= 15 + 52 - FFMIN(h->slice_alpha_c0_offset, h->slice_beta_offset) - FFMAX3(0, h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1]);
2416
2417 #if 0 //FMO
2418     if( h->pps.num_slice_groups > 1  && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5)
2419         slice_group_change_cycle= get_bits(&s->gb, ?);
2420 #endif
2421
2422     h0->last_slice_type = slice_type;
2423     h->slice_num = ++h0->current_slice;
2424     if(h->slice_num >= MAX_SLICES){
2425         av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
2426     }
2427
2428     for(j=0; j<2; j++){
2429         int id_list[16];
2430         int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j];
2431         for(i=0; i<16; i++){
2432             id_list[i]= 60;
2433             if(h->ref_list[j][i].data[0]){
2434                 int k;
2435                 uint8_t *base= h->ref_list[j][i].base[0];
2436                 for(k=0; k<h->short_ref_count; k++)
2437                     if(h->short_ref[k]->base[0] == base){
2438                         id_list[i]= k;
2439                         break;
2440                     }
2441                 for(k=0; k<h->long_ref_count; k++)
2442                     if(h->long_ref[k] && h->long_ref[k]->base[0] == base){
2443                         id_list[i]= h->short_ref_count + k;
2444                         break;
2445                     }
2446             }
2447         }
2448
2449         ref2frm[0]=
2450         ref2frm[1]= -1;
2451         for(i=0; i<16; i++)
2452             ref2frm[i+2]= 4*id_list[i]
2453                           +(h->ref_list[j][i].reference&3);
2454         ref2frm[18+0]=
2455         ref2frm[18+1]= -1;
2456         for(i=16; i<48; i++)
2457             ref2frm[i+4]= 4*id_list[(i-16)>>1]
2458                           +(h->ref_list[j][i].reference&3);
2459     }
2460
2461     //FIXME: fix draw_edges+PAFF+frame threads
2462     h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE || (!h->sps.frame_mbs_only_flag && s->avctx->active_thread_type)) ? 0 : 16;
2463     h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width;
2464
2465     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
2466         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",
2467                h->slice_num,
2468                (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"),
2469                first_mb_in_slice,
2470                av_get_picture_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
2471                pps_id, h->frame_num,
2472                s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1],
2473                h->ref_count[0], h->ref_count[1],
2474                s->qscale,
2475                h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26,
2476                h->use_weight,
2477                h->use_weight==1 && h->use_weight_chroma ? "c" : "",
2478                h->slice_type == AV_PICTURE_TYPE_B ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : ""
2479                );
2480     }
2481
2482     return 0;
2483 }
2484
2485 int ff_h264_get_slice_type(const H264Context *h)
2486 {
2487     switch (h->slice_type) {
2488     case AV_PICTURE_TYPE_P:  return 0;
2489     case AV_PICTURE_TYPE_B:  return 1;
2490     case AV_PICTURE_TYPE_I:  return 2;
2491     case AV_PICTURE_TYPE_SP: return 3;
2492     case AV_PICTURE_TYPE_SI: return 4;
2493     default:         return -1;
2494     }
2495 }
2496
2497 /**
2498  *
2499  * @return non zero if the loop filter can be skiped
2500  */
2501 static int fill_filter_caches(H264Context *h, int mb_type){
2502     MpegEncContext * const s = &h->s;
2503     const int mb_xy= h->mb_xy;
2504     int top_xy, left_xy[2];
2505     int top_type, left_type[2];
2506
2507     top_xy     = mb_xy  - (s->mb_stride << MB_FIELD);
2508
2509     //FIXME deblocking could skip the intra and nnz parts.
2510
2511     /* Wow, what a mess, why didn't they simplify the interlacing & intra
2512      * stuff, I can't imagine that these complex rules are worth it. */
2513
2514     left_xy[1] = left_xy[0] = mb_xy-1;
2515     if(FRAME_MBAFF){
2516         const int left_mb_field_flag     = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
2517         const int curr_mb_field_flag     = IS_INTERLACED(mb_type);
2518         if(s->mb_y&1){
2519             if (left_mb_field_flag != curr_mb_field_flag) {
2520                 left_xy[0] -= s->mb_stride;
2521             }
2522         }else{
2523             if(curr_mb_field_flag){
2524                 top_xy      += s->mb_stride & (((s->current_picture.mb_type[top_xy    ]>>7)&1)-1);
2525             }
2526             if (left_mb_field_flag != curr_mb_field_flag) {
2527                 left_xy[1] += s->mb_stride;
2528             }
2529         }
2530     }
2531
2532     h->top_mb_xy = top_xy;
2533     h->left_mb_xy[0] = left_xy[0];
2534     h->left_mb_xy[1] = left_xy[1];
2535     {
2536         //for sufficiently low qp, filtering wouldn't do anything
2537         //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
2538         int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
2539         int qp = s->current_picture.qscale_table[mb_xy];
2540         if(qp <= qp_thresh
2541            && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
2542            && (top_xy   < 0 || ((qp + s->current_picture.qscale_table[top_xy    ] + 1)>>1) <= qp_thresh)){
2543             if(!FRAME_MBAFF)
2544                 return 1;
2545             if(   (left_xy[0]< 0            || ((qp + s->current_picture.qscale_table[left_xy[1]             ] + 1)>>1) <= qp_thresh)
2546                && (top_xy    < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy    -s->mb_stride] + 1)>>1) <= qp_thresh))
2547                 return 1;
2548         }
2549     }
2550
2551     top_type     = s->current_picture.mb_type[top_xy]    ;
2552     left_type[0] = s->current_picture.mb_type[left_xy[0]];
2553     left_type[1] = s->current_picture.mb_type[left_xy[1]];
2554     if(h->deblocking_filter == 2){
2555         if(h->slice_table[top_xy     ] != h->slice_num) top_type= 0;
2556         if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
2557     }else{
2558         if(h->slice_table[top_xy     ] == 0xFFFF) top_type= 0;
2559         if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
2560     }
2561     h->top_type    = top_type    ;
2562     h->left_type[0]= left_type[0];
2563     h->left_type[1]= left_type[1];
2564
2565     if(IS_INTRA(mb_type))
2566         return 0;
2567
2568     AV_COPY32(&h->non_zero_count_cache[4+8*1], &h->non_zero_count[mb_xy][ 4]);
2569     AV_COPY32(&h->non_zero_count_cache[4+8*2], &h->non_zero_count[mb_xy][12]);
2570     AV_COPY32(&h->non_zero_count_cache[4+8*3], &h->non_zero_count[mb_xy][20]);
2571     AV_COPY32(&h->non_zero_count_cache[4+8*4], &h->non_zero_count[mb_xy][28]);
2572
2573     h->cbp= h->cbp_table[mb_xy];
2574
2575     {
2576         int list;
2577         for(list=0; list<h->list_count; list++){
2578             int8_t *ref;
2579             int y, b_stride;
2580             int16_t (*mv_dst)[2];
2581             int16_t (*mv_src)[2];
2582
2583             if(!USES_LIST(mb_type, list)){
2584                 fill_rectangle(  h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
2585                 AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2586                 AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2587                 AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2588                 AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2589                 continue;
2590             }
2591
2592             ref = &s->current_picture.ref_index[list][4*mb_xy];
2593             {
2594                 int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2595                 AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2596                 AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2597                 ref += 2;
2598                 AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2599                 AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
2600             }
2601
2602             b_stride = h->b_stride;
2603             mv_dst   = &h->mv_cache[list][scan8[0]];
2604             mv_src   = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
2605             for(y=0; y<4; y++){
2606                 AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
2607             }
2608
2609         }
2610     }
2611
2612
2613 /*
2614 0 . T T. T T T T
2615 1 L . .L . . . .
2616 2 L . .L . . . .
2617 3 . T TL . . . .
2618 4 L . .L . . . .
2619 5 L . .. . . . .
2620 */
2621 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
2622     if(top_type){
2623         AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]);
2624     }
2625
2626     if(left_type[0]){
2627         h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8];
2628         h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8];
2629         h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8];
2630         h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8];
2631     }
2632
2633     // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
2634     if(!CABAC && h->pps.transform_8x8_mode){
2635         if(IS_8x8DCT(top_type)){
2636             h->non_zero_count_cache[4+8*0]=
2637             h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4;
2638             h->non_zero_count_cache[6+8*0]=
2639             h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8;
2640         }
2641         if(IS_8x8DCT(left_type[0])){
2642             h->non_zero_count_cache[3+8*1]=
2643             h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF
2644         }
2645         if(IS_8x8DCT(left_type[1])){
2646             h->non_zero_count_cache[3+8*3]=
2647             h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF
2648         }
2649
2650         if(IS_8x8DCT(mb_type)){
2651             h->non_zero_count_cache[scan8[0   ]]= h->non_zero_count_cache[scan8[1   ]]=
2652             h->non_zero_count_cache[scan8[2   ]]= h->non_zero_count_cache[scan8[3   ]]= h->cbp & 1;
2653
2654             h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
2655             h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2;
2656
2657             h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
2658             h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4;
2659
2660             h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
2661             h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8;
2662         }
2663     }
2664
2665     if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
2666         int list;
2667         for(list=0; list<h->list_count; list++){
2668             if(USES_LIST(top_type, list)){
2669                 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
2670                 const int b8_xy= 4*top_xy + 2;
2671                 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2672                 AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
2673                 h->ref_cache[list][scan8[0] + 0 - 1*8]=
2674                 h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
2675                 h->ref_cache[list][scan8[0] + 2 - 1*8]=
2676                 h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
2677             }else{
2678                 AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
2679                 AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
2680             }
2681
2682             if(!IS_INTERLACED(mb_type^left_type[0])){
2683                 if(USES_LIST(left_type[0], list)){
2684                     const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
2685                     const int b8_xy= 4*left_xy[0] + 1;
2686                     int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
2687                     AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
2688                     AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
2689                     AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
2690                     AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
2691                     h->ref_cache[list][scan8[0] - 1 + 0 ]=
2692                     h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
2693                     h->ref_cache[list][scan8[0] - 1 +16 ]=
2694                     h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
2695                 }else{
2696                     AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
2697                     AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
2698                     AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
2699                     AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
2700                     h->ref_cache[list][scan8[0] - 1 + 0  ]=
2701                     h->ref_cache[list][scan8[0] - 1 + 8  ]=
2702                     h->ref_cache[list][scan8[0] - 1 + 16 ]=
2703                     h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
2704                 }
2705             }
2706         }
2707     }
2708
2709     return 0;
2710 }
2711
2712 static void loop_filter(H264Context *h, int start_x, int end_x){
2713     MpegEncContext * const s = &h->s;
2714     uint8_t  *dest_y, *dest_cb, *dest_cr;
2715     int linesize, uvlinesize, mb_x, mb_y;
2716     const int end_mb_y= s->mb_y + FRAME_MBAFF;
2717     const int old_slice_type= h->slice_type;
2718     const int pixel_shift = h->pixel_shift;
2719
2720     if(h->deblocking_filter) {
2721         for(mb_x= start_x; mb_x<end_x; mb_x++){
2722             for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){
2723                 int mb_xy, mb_type;
2724                 mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride;
2725                 h->slice_num= h->slice_table[mb_xy];
2726                 mb_type= s->current_picture.mb_type[mb_xy];
2727                 h->list_count= h->list_counts[mb_xy];
2728
2729                 if(FRAME_MBAFF)
2730                     h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2731
2732                 s->mb_x= mb_x;
2733                 s->mb_y= mb_y;
2734                 dest_y  = s->current_picture.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
2735                 dest_cb = s->current_picture.data[1] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
2736                 dest_cr = s->current_picture.data[2] + ((mb_x << pixel_shift) + mb_y * s->uvlinesize) * 8;
2737                     //FIXME simplify above
2738
2739                 if (MB_FIELD) {
2740                     linesize   = h->mb_linesize   = s->linesize * 2;
2741                     uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
2742                     if(mb_y&1){ //FIXME move out of this function?
2743                         dest_y -= s->linesize*15;
2744                         dest_cb-= s->uvlinesize*7;
2745                         dest_cr-= s->uvlinesize*7;
2746                     }
2747                 } else {
2748                     linesize   = h->mb_linesize   = s->linesize;
2749                     uvlinesize = h->mb_uvlinesize = s->uvlinesize;
2750                 }
2751                 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0);
2752                 if(fill_filter_caches(h, mb_type))
2753                     continue;
2754                 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]);
2755                 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]);
2756
2757                 if (FRAME_MBAFF) {
2758                     ff_h264_filter_mb     (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2759                 } else {
2760                     ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize);
2761                 }
2762             }
2763         }
2764     }
2765     h->slice_type= old_slice_type;
2766     s->mb_x= end_x;
2767     s->mb_y= end_mb_y - FRAME_MBAFF;
2768     h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale);
2769     h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale);
2770 }
2771
2772 static void predict_field_decoding_flag(H264Context *h){
2773     MpegEncContext * const s = &h->s;
2774     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
2775     int mb_type = (h->slice_table[mb_xy-1] == h->slice_num)
2776                 ? s->current_picture.mb_type[mb_xy-1]
2777                 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num)
2778                 ? s->current_picture.mb_type[mb_xy-s->mb_stride]
2779                 : 0;
2780     h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2781 }
2782
2783 /**
2784  * Draw edges and report progress for the last MB row.
2785  */
2786 static void decode_finish_row(H264Context *h){
2787     MpegEncContext * const s = &h->s;
2788     int top = 16*(s->mb_y >> FIELD_PICTURE);
2789     int height = 16 << FRAME_MBAFF;
2790     int deblock_border = (16 + 4) << FRAME_MBAFF;
2791     int pic_height = 16*s->mb_height >> FIELD_PICTURE;
2792
2793     if (h->deblocking_filter) {
2794         if((top + height) >= pic_height)
2795             height += deblock_border;
2796
2797         top -= deblock_border;
2798     }
2799
2800     if (top >= pic_height || (top + height) < h->emu_edge_height)
2801         return;
2802
2803     height = FFMIN(height, pic_height - top);
2804     if (top < h->emu_edge_height) {
2805         height = top+height;
2806         top = 0;
2807     }
2808
2809     ff_draw_horiz_band(s, top, height);
2810
2811     if (s->dropable) return;
2812
2813     ff_thread_report_progress((AVFrame*)s->current_picture_ptr, top + height - 1,
2814                              s->picture_structure==PICT_BOTTOM_FIELD);
2815 }
2816
2817 static int decode_slice(struct AVCodecContext *avctx, void *arg){
2818     H264Context *h = *(void**)arg;
2819     MpegEncContext * const s = &h->s;
2820     const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F;
2821     int lf_x_start = s->mb_x;
2822
2823     s->mb_skip_run= -1;
2824
2825     h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 ||
2826                     (CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY));
2827
2828     if( h->pps.cabac ) {
2829         /* realign */
2830         align_get_bits( &s->gb );
2831
2832         /* init cabac */
2833         ff_init_cabac_states( &h->cabac);
2834         ff_init_cabac_decoder( &h->cabac,
2835                                s->gb.buffer + get_bits_count(&s->gb)/8,
2836                                (get_bits_left(&s->gb) + 7)/8);
2837
2838         ff_h264_init_cabac_states(h);
2839
2840         for(;;){
2841 //START_TIMER
2842             int ret = ff_h264_decode_mb_cabac(h);
2843             int eos;
2844 //STOP_TIMER("decode_mb_cabac")
2845
2846             if(ret>=0) ff_h264_hl_decode_mb(h);
2847
2848             if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ?
2849                 s->mb_y++;
2850
2851                 ret = ff_h264_decode_mb_cabac(h);
2852
2853                 if(ret>=0) ff_h264_hl_decode_mb(h);
2854                 s->mb_y--;
2855             }
2856             eos = get_cabac_terminate( &h->cabac );
2857
2858             if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){
2859                 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);
2860                 if (s->mb_x >= lf_x_start) loop_filter(h, lf_x_start, s->mb_x + 1);
2861                 return 0;
2862             }
2863             if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
2864                 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);
2865                 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);
2866                 return -1;
2867             }
2868
2869             if( ++s->mb_x >= s->mb_width ) {
2870                 loop_filter(h, lf_x_start, s->mb_x);
2871                 s->mb_x = lf_x_start = 0;
2872                 decode_finish_row(h);
2873                 ++s->mb_y;
2874                 if(FIELD_OR_MBAFF_PICTURE) {
2875                     ++s->mb_y;
2876                     if(FRAME_MBAFF && s->mb_y < s->mb_height)
2877                         predict_field_decoding_flag(h);
2878                 }
2879             }
2880
2881             if( eos || s->mb_y >= s->mb_height ) {
2882                 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
2883                 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);
2884                 if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);
2885                 return 0;
2886             }
2887         }
2888
2889     } else {
2890         for(;;){
2891             int ret = ff_h264_decode_mb_cavlc(h);
2892
2893             if(ret>=0) ff_h264_hl_decode_mb(h);
2894
2895             if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ?
2896                 s->mb_y++;
2897                 ret = ff_h264_decode_mb_cavlc(h);
2898
2899                 if(ret>=0) ff_h264_hl_decode_mb(h);
2900                 s->mb_y--;
2901             }
2902
2903             if(ret<0){
2904                 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
2905                 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);
2906                 return -1;
2907             }
2908
2909             if(++s->mb_x >= s->mb_width){
2910                 loop_filter(h, lf_x_start, s->mb_x);
2911                 s->mb_x = lf_x_start = 0;
2912                 decode_finish_row(h);
2913                 ++s->mb_y;
2914                 if(FIELD_OR_MBAFF_PICTURE) {
2915                     ++s->mb_y;
2916                     if(FRAME_MBAFF && s->mb_y < s->mb_height)
2917                         predict_field_decoding_flag(h);
2918                 }
2919                 if(s->mb_y >= s->mb_height){
2920                     tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
2921
2922                     if(   get_bits_count(&s->gb) == s->gb.size_in_bits
2923                        || get_bits_count(&s->gb) <  s->gb.size_in_bits && s->avctx->error_recognition < FF_ER_AGGRESSIVE) {
2924                         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);
2925
2926                         return 0;
2927                     }else{
2928                         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);
2929
2930                         return -1;
2931                     }
2932                 }
2933             }
2934
2935             if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){
2936                 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
2937                 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){
2938                     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);
2939                     if (s->mb_x > lf_x_start) loop_filter(h, lf_x_start, s->mb_x);
2940
2941                     return 0;
2942                 }else{
2943                     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);
2944
2945                     return -1;
2946                 }
2947             }
2948         }
2949     }
2950
2951 #if 0
2952     for(;s->mb_y < s->mb_height; s->mb_y++){
2953         for(;s->mb_x < s->mb_width; s->mb_x++){
2954             int ret= decode_mb(h);
2955
2956             ff_h264_hl_decode_mb(h);
2957
2958             if(ret<0){
2959                 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
2960                 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);
2961
2962                 return -1;
2963             }
2964
2965             if(++s->mb_x >= s->mb_width){
2966                 s->mb_x=0;
2967                 if(++s->mb_y >= s->mb_height){
2968                     if(get_bits_count(s->gb) == s->gb.size_in_bits){
2969                         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);
2970
2971                         return 0;
2972                     }else{
2973                         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);
2974
2975                         return -1;
2976                     }
2977                 }
2978             }
2979
2980             if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){
2981                 if(get_bits_count(s->gb) == s->gb.size_in_bits){
2982                     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);
2983
2984                     return 0;
2985                 }else{
2986                     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);
2987
2988                     return -1;
2989                 }
2990             }
2991         }
2992         s->mb_x=0;
2993         ff_draw_horiz_band(s, 16*s->mb_y, 16);
2994     }
2995 #endif
2996     return -1; //not reached
2997 }
2998
2999 /**
3000  * Call decode_slice() for each context.
3001  *
3002  * @param h h264 master context
3003  * @param context_count number of contexts to execute
3004  */
3005 static void execute_decode_slices(H264Context *h, int context_count){
3006     MpegEncContext * const s = &h->s;
3007     AVCodecContext * const avctx= s->avctx;
3008     H264Context *hx;
3009     int i;
3010
3011     if (s->avctx->hwaccel)
3012         return;
3013     if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3014         return;
3015     if(context_count == 1) {
3016         decode_slice(avctx, &h);
3017     } else {
3018         for(i = 1; i < context_count; i++) {
3019             hx = h->thread_context[i];
3020             hx->s.error_recognition = avctx->error_recognition;
3021             hx->s.error_count = 0;
3022             hx->x264_build= h->x264_build;
3023         }
3024
3025         avctx->execute(avctx, (void *)decode_slice,
3026                        h->thread_context, NULL, context_count, sizeof(void*));
3027
3028         /* pull back stuff from slices to master context */
3029         hx = h->thread_context[context_count - 1];
3030         s->mb_x = hx->s.mb_x;
3031         s->mb_y = hx->s.mb_y;
3032         s->dropable = hx->s.dropable;
3033         s->picture_structure = hx->s.picture_structure;
3034         for(i = 1; i < context_count; i++)
3035             h->s.error_count += h->thread_context[i]->s.error_count;
3036     }
3037 }
3038
3039
3040 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){
3041     MpegEncContext * const s = &h->s;
3042     AVCodecContext * const avctx= s->avctx;
3043     H264Context *hx; ///< thread context
3044     int buf_index;
3045     int context_count;
3046     int next_avc;
3047     int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
3048     int nals_needed=0; ///< number of NALs that need decoding before the next frame thread starts
3049     int nal_index;
3050
3051     h->max_contexts = (HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_SLICE)) ? avctx->thread_count : 1;
3052     if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){
3053         h->current_slice = 0;
3054         if (!s->first_field)
3055             s->current_picture_ptr= NULL;
3056         ff_h264_reset_sei(h);
3057     }
3058
3059     for(;pass <= 1;pass++){
3060         buf_index = 0;
3061         context_count = 0;
3062         next_avc = h->is_avc ? 0 : buf_size;
3063         nal_index = 0;
3064     for(;;){
3065         int consumed;
3066         int dst_length;
3067         int bit_length;
3068         const uint8_t *ptr;
3069         int i, nalsize = 0;
3070         int err;
3071
3072         if(buf_index >= next_avc) {
3073             if(buf_index >= buf_size) break;
3074             nalsize = 0;
3075             for(i = 0; i < h->nal_length_size; i++)
3076                 nalsize = (nalsize << 8) | buf[buf_index++];
3077             if(nalsize <= 0 || nalsize > buf_size - buf_index){
3078                 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
3079                 break;
3080             }
3081             next_avc= buf_index + nalsize;
3082         } else {
3083             // start code prefix search
3084             for(; buf_index + 3 < next_avc; buf_index++){
3085                 // This should always succeed in the first iteration.
3086                 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1)
3087                     break;
3088             }
3089
3090             if(buf_index+3 >= buf_size) break;
3091
3092             buf_index+=3;
3093             if(buf_index >= next_avc) continue;
3094         }
3095
3096         hx = h->thread_context[context_count];
3097
3098         ptr= ff_h264_decode_nal(hx, buf + buf_index, &dst_length, &consumed, next_avc - buf_index);
3099         if (ptr==NULL || dst_length < 0){
3100             return -1;
3101         }
3102         i= buf_index + consumed;
3103         if((s->workaround_bugs & FF_BUG_AUTODETECT) && i+3<next_avc &&
3104            buf[i]==0x00 && buf[i+1]==0x00 && buf[i+2]==0x01 && buf[i+3]==0xE0)
3105             s->workaround_bugs |= FF_BUG_TRUNCATED;
3106
3107         if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){
3108         while(ptr[dst_length - 1] == 0 && dst_length > 0)
3109             dst_length--;
3110         }
3111         bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
3112
3113         if(s->avctx->debug&FF_DEBUG_STARTCODE){
3114             av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d/%d at %d/%d length %d\n", hx->nal_unit_type, hx->nal_ref_idc, buf_index, buf_size, dst_length);
3115         }
3116
3117         if (h->is_avc && (nalsize != consumed) && nalsize){
3118             av_log(h->s.avctx, AV_LOG_DEBUG, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize);
3119         }
3120
3121         buf_index += consumed;
3122         nal_index++;
3123
3124         if(pass == 0) {
3125             // packets can sometimes contain multiple PPS/SPS
3126             // e.g. two PAFF field pictures in one packet, or a demuxer which splits NALs strangely
3127             // if so, when frame threading we can't start the next thread until we've read all of them
3128             switch (hx->nal_unit_type) {
3129                 case NAL_SPS:
3130                 case NAL_PPS:
3131                     nals_needed = nal_index;
3132             }
3133             continue;
3134         }
3135
3136         //FIXME do not discard SEI id
3137         if(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc  == 0)
3138             continue;
3139
3140       again:
3141         err = 0;
3142         switch(hx->nal_unit_type){
3143         case NAL_IDR_SLICE:
3144             if (h->nal_unit_type != NAL_IDR_SLICE) {
3145                 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices");
3146                 return -1;
3147             }
3148             idr(h); //FIXME ensure we don't loose some frames if there is reordering
3149         case NAL_SLICE:
3150             init_get_bits(&hx->s.gb, ptr, bit_length);
3151             hx->intra_gb_ptr=
3152             hx->inter_gb_ptr= &hx->s.gb;
3153             hx->s.data_partitioning = 0;
3154
3155             if((err = decode_slice_header(hx, h)))
3156                break;
3157
3158             s->current_picture_ptr->key_frame |=
3159                     (hx->nal_unit_type == NAL_IDR_SLICE) ||
3160                     (h->sei_recovery_frame_cnt >= 0);
3161
3162             if (h->current_slice == 1) {
3163                 if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {
3164                     decode_postinit(h, nal_index >= nals_needed);
3165                 }
3166
3167                 if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0)
3168                     return -1;
3169                 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
3170                     ff_vdpau_h264_picture_start(s);
3171             }
3172
3173             if(hx->redundant_pic_count==0
3174                && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
3175                && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=AV_PICTURE_TYPE_B)
3176                && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)
3177                && avctx->skip_frame < AVDISCARD_ALL){
3178                 if(avctx->hwaccel) {
3179                     if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0)
3180                         return -1;
3181                 }else
3182                 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){
3183                     static const uint8_t start_code[] = {0x00, 0x00, 0x01};
3184                     ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code));
3185                     ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed );
3186                 }else
3187                     context_count++;
3188             }
3189             break;
3190         case NAL_DPA:
3191             init_get_bits(&hx->s.gb, ptr, bit_length);
3192             hx->intra_gb_ptr=
3193             hx->inter_gb_ptr= NULL;
3194
3195             if ((err = decode_slice_header(hx, h)) < 0)
3196                 break;
3197
3198             hx->s.data_partitioning = 1;
3199
3200             break;
3201         case NAL_DPB:
3202             init_get_bits(&hx->intra_gb, ptr, bit_length);
3203             hx->intra_gb_ptr= &hx->intra_gb;
3204             break;
3205         case NAL_DPC:
3206             init_get_bits(&hx->inter_gb, ptr, bit_length);
3207             hx->inter_gb_ptr= &hx->inter_gb;
3208
3209             if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning
3210                && s->context_initialized
3211                && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc)
3212                && (avctx->skip_frame < AVDISCARD_BIDIR  || hx->slice_type_nos!=AV_PICTURE_TYPE_B)
3213                && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==AV_PICTURE_TYPE_I)
3214                && avctx->skip_frame < AVDISCARD_ALL)
3215                 context_count++;
3216             break;
3217         case NAL_SEI:
3218             init_get_bits(&s->gb, ptr, bit_length);
3219             ff_h264_decode_sei(h);
3220             break;
3221         case NAL_SPS:
3222             init_get_bits(&s->gb, ptr, bit_length);
3223             ff_h264_decode_seq_parameter_set(h);
3224
3225             if(s->flags& CODEC_FLAG_LOW_DELAY ||
3226               (h->sps.bitstream_restriction_flag && !h->sps.num_reorder_frames))
3227                 s->low_delay=1;
3228
3229             if(avctx->has_b_frames < 2)
3230                 avctx->has_b_frames= !s->low_delay;
3231
3232             if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma) {
3233                 if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
3234                     avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
3235                     h->pixel_shift = h->sps.bit_depth_luma > 8;
3236
3237                     ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma);
3238                     ff_h264_pred_init(&h->hpc, s->codec_id, h->sps.bit_depth_luma);
3239                     dsputil_init(&s->dsp, s->avctx);
3240                 } else {
3241                     av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", h->sps.bit_depth_luma);
3242                     return -1;
3243                 }
3244             }
3245             break;
3246         case NAL_PPS:
3247             init_get_bits(&s->gb, ptr, bit_length);
3248
3249             ff_h264_decode_picture_parameter_set(h, bit_length);
3250
3251             break;
3252         case NAL_AUD:
3253         case NAL_END_SEQUENCE:
3254         case NAL_END_STREAM:
3255         case NAL_FILLER_DATA:
3256         case NAL_SPS_EXT:
3257         case NAL_AUXILIARY_SLICE:
3258             break;
3259         default:
3260             av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", hx->nal_unit_type, bit_length);
3261         }
3262
3263         if(context_count == h->max_contexts) {
3264             execute_decode_slices(h, context_count);
3265             context_count = 0;
3266         }
3267
3268         if (err < 0)
3269             av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n");
3270         else if(err == 1) {
3271             /* Slice could not be decoded in parallel mode, copy down
3272              * NAL unit stuff to context 0 and restart. Note that
3273              * rbsp_buffer is not transferred, but since we no longer
3274              * run in parallel mode this should not be an issue. */
3275             h->nal_unit_type = hx->nal_unit_type;
3276             h->nal_ref_idc   = hx->nal_ref_idc;
3277             hx = h;
3278             goto again;
3279         }
3280     }
3281     }
3282     if(context_count)
3283         execute_decode_slices(h, context_count);
3284     return buf_index;
3285 }
3286
3287 /**
3288  * returns the number of bytes consumed for building the current frame
3289  */
3290 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){
3291         if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
3292         if(pos+10>buf_size) pos=buf_size; // oops ;)
3293
3294         return pos;
3295 }
3296
3297 static int decode_frame(AVCodecContext *avctx,
3298                              void *data, int *data_size,
3299                              AVPacket *avpkt)
3300 {
3301     const uint8_t *buf = avpkt->data;
3302     int buf_size = avpkt->size;
3303     H264Context *h = avctx->priv_data;
3304     MpegEncContext *s = &h->s;
3305     AVFrame *pict = data;
3306     int buf_index;
3307
3308     s->flags= avctx->flags;
3309     s->flags2= avctx->flags2;
3310
3311    /* end of stream, output what is still in the buffers */
3312  out:
3313     if (buf_size == 0) {
3314         Picture *out;
3315         int i, out_idx;
3316
3317         s->current_picture_ptr = NULL;
3318
3319 //FIXME factorize this with the output code below
3320         out = h->delayed_pic[0];
3321         out_idx = 0;
3322         for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++)
3323             if(h->delayed_pic[i]->poc < out->poc){
3324                 out = h->delayed_pic[i];
3325                 out_idx = i;
3326             }
3327
3328         for(i=out_idx; h->delayed_pic[i]; i++)
3329             h->delayed_pic[i] = h->delayed_pic[i+1];
3330
3331         if(out){
3332             *data_size = sizeof(AVFrame);
3333             *pict= *(AVFrame*)out;
3334         }
3335
3336         return 0;
3337     }
3338
3339     buf_index=decode_nal_units(h, buf, buf_size);
3340     if(buf_index < 0)
3341         return -1;
3342
3343     if (!s->current_picture_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
3344         buf_size = 0;
3345         goto out;
3346     }
3347
3348     if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){
3349         if (avctx->skip_frame >= AVDISCARD_NONREF)
3350             return 0;
3351         av_log(avctx, AV_LOG_ERROR, "no frame!\n");
3352         return -1;
3353     }
3354
3355     if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){
3356
3357         if(s->flags2 & CODEC_FLAG2_CHUNKS) decode_postinit(h, 1);
3358
3359         field_end(h, 0);
3360
3361         if (!h->next_output_pic) {
3362             /* Wait for second field. */
3363             *data_size = 0;
3364
3365         } else {
3366             *data_size = sizeof(AVFrame);
3367             *pict = *(AVFrame*)h->next_output_pic;
3368         }
3369     }
3370
3371     assert(pict->data[0] || !*data_size);
3372     ff_print_debug_info(s, pict);
3373 //printf("out %d\n", (int)pict->data[0]);
3374
3375     return get_consumed_bytes(s, buf_index, buf_size);
3376 }
3377 #if 0
3378 static inline void fill_mb_avail(H264Context *h){
3379     MpegEncContext * const s = &h->s;
3380     const int mb_xy= s->mb_x + s->mb_y*s->mb_stride;
3381
3382     if(s->mb_y){
3383         h->mb_avail[0]= s->mb_x                 && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num;
3384         h->mb_avail[1]=                            h->slice_table[mb_xy - s->mb_stride    ] == h->slice_num;
3385         h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num;
3386     }else{
3387         h->mb_avail[0]=
3388         h->mb_avail[1]=
3389         h->mb_avail[2]= 0;
3390     }
3391     h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num;
3392     h->mb_avail[4]= 1; //FIXME move out
3393     h->mb_avail[5]= 0; //FIXME move out
3394 }
3395 #endif
3396
3397 #ifdef TEST
3398 #undef printf
3399 #undef random
3400 #define COUNT 8000
3401 #define SIZE (COUNT*40)
3402 int main(void){
3403     int i;
3404     uint8_t temp[SIZE];
3405     PutBitContext pb;
3406     GetBitContext gb;
3407 //    int int_temp[10000];
3408     DSPContext dsp;
3409     AVCodecContext avctx;
3410
3411     dsputil_init(&dsp, &avctx);
3412
3413     init_put_bits(&pb, temp, SIZE);
3414     printf("testing unsigned exp golomb\n");
3415     for(i=0; i<COUNT; i++){
3416         START_TIMER
3417         set_ue_golomb(&pb, i);
3418         STOP_TIMER("set_ue_golomb");
3419     }
3420     flush_put_bits(&pb);
3421
3422     init_get_bits(&gb, temp, 8*SIZE);
3423     for(i=0; i<COUNT; i++){
3424         int j, s;
3425
3426         s= show_bits(&gb, 24);
3427
3428         START_TIMER
3429         j= get_ue_golomb(&gb);
3430         if(j != i){
3431             printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
3432 //            return -1;
3433         }
3434         STOP_TIMER("get_ue_golomb");
3435     }
3436
3437
3438     init_put_bits(&pb, temp, SIZE);
3439     printf("testing signed exp golomb\n");
3440     for(i=0; i<COUNT; i++){
3441         START_TIMER
3442         set_se_golomb(&pb, i - COUNT/2);
3443         STOP_TIMER("set_se_golomb");
3444     }
3445     flush_put_bits(&pb);
3446
3447     init_get_bits(&gb, temp, 8*SIZE);
3448     for(i=0; i<COUNT; i++){
3449         int j, s;
3450
3451         s= show_bits(&gb, 24);
3452
3453         START_TIMER
3454         j= get_se_golomb(&gb);
3455         if(j != i - COUNT/2){
3456             printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s);
3457 //            return -1;
3458         }
3459         STOP_TIMER("get_se_golomb");
3460     }
3461
3462 #if 0
3463     printf("testing 4x4 (I)DCT\n");
3464
3465     DCTELEM block[16];
3466     uint8_t src[16], ref[16];
3467     uint64_t error= 0, max_error=0;
3468
3469     for(i=0; i<COUNT; i++){
3470         int j;
3471 //        printf("%d %d %d\n", r1, r2, (r2-r1)*16);
3472         for(j=0; j<16; j++){
3473             ref[j]= random()%255;
3474             src[j]= random()%255;
3475         }
3476
3477         h264_diff_dct_c(block, src, ref, 4);
3478
3479         //normalize
3480         for(j=0; j<16; j++){
3481 //            printf("%d ", block[j]);
3482             block[j]= block[j]*4;
3483             if(j&1) block[j]= (block[j]*4 + 2)/5;
3484             if(j&4) block[j]= (block[j]*4 + 2)/5;
3485         }
3486 //        printf("\n");
3487
3488         h->h264dsp.h264_idct_add(ref, block, 4);
3489 /*        for(j=0; j<16; j++){
3490             printf("%d ", ref[j]);
3491         }
3492         printf("\n");*/
3493
3494         for(j=0; j<16; j++){
3495             int diff= FFABS(src[j] - ref[j]);
3496
3497             error+= diff*diff;
3498             max_error= FFMAX(max_error, diff);
3499         }
3500     }
3501     printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error );
3502     printf("testing quantizer\n");
3503     for(qp=0; qp<52; qp++){
3504         for(i=0; i<16; i++)
3505             src1_block[i]= src2_block[i]= random()%255;
3506
3507     }
3508     printf("Testing NAL layer\n");
3509
3510     uint8_t bitstream[COUNT];
3511     uint8_t nal[COUNT*2];
3512     H264Context h;
3513     memset(&h, 0, sizeof(H264Context));
3514
3515     for(i=0; i<COUNT; i++){
3516         int zeros= i;
3517         int nal_length;
3518         int consumed;
3519         int out_length;
3520         uint8_t *out;
3521         int j;
3522
3523         for(j=0; j<COUNT; j++){
3524             bitstream[j]= (random() % 255) + 1;
3525         }
3526
3527         for(j=0; j<zeros; j++){
3528             int pos= random() % COUNT;
3529             while(bitstream[pos] == 0){
3530                 pos++;
3531                 pos %= COUNT;
3532             }
3533             bitstream[pos]=0;
3534         }
3535
3536         START_TIMER
3537
3538         nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2);
3539         if(nal_length<0){
3540             printf("encoding failed\n");
3541             return -1;
3542         }
3543
3544         out= ff_h264_decode_nal(&h, nal, &out_length, &consumed, nal_length);
3545
3546         STOP_TIMER("NAL")
3547
3548         if(out_length != COUNT){
3549             printf("incorrect length %d %d\n", out_length, COUNT);
3550             return -1;
3551         }
3552
3553         if(consumed != nal_length){
3554             printf("incorrect consumed length %d %d\n", nal_length, consumed);
3555             return -1;
3556         }
3557
3558         if(memcmp(bitstream, out, COUNT)){
3559             printf("mismatch\n");
3560             return -1;
3561         }
3562     }
3563 #endif
3564
3565     printf("Testing RBSP\n");
3566
3567
3568     return 0;
3569 }
3570 #endif /* TEST */
3571
3572
3573 av_cold void ff_h264_free_context(H264Context *h)
3574 {
3575     int i;
3576
3577     free_tables(h, 1); //FIXME cleanup init stuff perhaps
3578
3579     for(i = 0; i < MAX_SPS_COUNT; i++)
3580         av_freep(h->sps_buffers + i);
3581
3582     for(i = 0; i < MAX_PPS_COUNT; i++)
3583         av_freep(h->pps_buffers + i);
3584 }
3585
3586 av_cold int ff_h264_decode_end(AVCodecContext *avctx)
3587 {
3588     H264Context *h = avctx->priv_data;
3589     MpegEncContext *s = &h->s;
3590
3591     ff_h264_free_context(h);
3592
3593     MPV_common_end(s);
3594
3595 //    memset(h, 0, sizeof(H264Context));
3596
3597     return 0;
3598 }
3599
3600 static const AVProfile profiles[] = {
3601     { FF_PROFILE_H264_BASELINE,             "Baseline"              },
3602     { FF_PROFILE_H264_CONSTRAINED_BASELINE, "Constrained Baseline"  },
3603     { FF_PROFILE_H264_MAIN,                 "Main"                  },
3604     { FF_PROFILE_H264_EXTENDED,             "Extended"              },
3605     { FF_PROFILE_H264_HIGH,                 "High"                  },
3606     { FF_PROFILE_H264_HIGH_10,              "High 10"               },
3607     { FF_PROFILE_H264_HIGH_10_INTRA,        "High 10 Intra"         },
3608     { FF_PROFILE_H264_HIGH_422,             "High 4:2:2"            },
3609     { FF_PROFILE_H264_HIGH_422_INTRA,       "High 4:2:2 Intra"      },
3610     { FF_PROFILE_H264_HIGH_444,             "High 4:4:4"            },
3611     { FF_PROFILE_H264_HIGH_444_PREDICTIVE,  "High 4:4:4 Predictive" },
3612     { FF_PROFILE_H264_HIGH_444_INTRA,       "High 4:4:4 Intra"      },
3613     { FF_PROFILE_H264_CAVLC_444,            "CAVLC 4:4:4"           },
3614     { FF_PROFILE_UNKNOWN },
3615 };
3616
3617 AVCodec ff_h264_decoder = {
3618     "h264",
3619     AVMEDIA_TYPE_VIDEO,
3620     CODEC_ID_H264,
3621     sizeof(H264Context),
3622     ff_h264_decode_init,
3623     NULL,
3624     ff_h264_decode_end,
3625     decode_frame,
3626     /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY |
3627         CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS,
3628     .flush= flush_dpb,
3629     .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
3630     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
3631     .update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),
3632     .profiles = NULL_IF_CONFIG_SMALL(profiles),
3633 };
3634
3635 #if CONFIG_H264_VDPAU_DECODER
3636 AVCodec ff_h264_vdpau_decoder = {
3637     "h264_vdpau",
3638     AVMEDIA_TYPE_VIDEO,
3639     CODEC_ID_H264,
3640     sizeof(H264Context),
3641     ff_h264_decode_init,
3642     NULL,
3643     ff_h264_decode_end,
3644     decode_frame,
3645     CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
3646     .flush= flush_dpb,
3647     .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
3648     .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE},
3649     .profiles = NULL_IF_CONFIG_SMALL(profiles),
3650 };
3651 #endif