Merge commit 'e0c16e4e3259cf50b5bac4c23bb6e517f397c74b'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Mar 2014 11:33:33 +0000 (12:33 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 17 Mar 2014 11:36:48 +0000 (12:36 +0100)
* commit 'e0c16e4e3259cf50b5bac4c23bb6e517f397c74b':
  mpegvideo: move mpegvideo formats-related defines to mpegutils.h

Conflicts:
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_mvpred.h
libavcodec/svq1enc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
42 files changed:
1  2 
libavcodec/dxva2_h264.c
libavcodec/dxva2_mpeg2.c
libavcodec/dxva2_vc1.c
libavcodec/error_resilience.c
libavcodec/h261dec.c
libavcodec/h261enc.c
libavcodec/h263.c
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_direct.c
libavcodec/h264_loopfilter.c
libavcodec/h264_mvpred.h
libavcodec/h264_parser.c
libavcodec/h264_refs.c
libavcodec/ituh263dec.c
libavcodec/ituh263enc.c
libavcodec/motion_est.c
libavcodec/mpeg12dec.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4video.c
libavcodec/mpeg4videodec.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegutils.h
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/mpegvideo_motion.c
libavcodec/mpegvideo_xvmc.c
libavcodec/msmpeg4dec.c
libavcodec/ratecontrol.c
libavcodec/rv30.c
libavcodec/rv34.c
libavcodec/rv40.c
libavcodec/svq1enc.c
libavcodec/svq3.c
libavcodec/vaapi_h264.c
libavcodec/vaapi_mpeg2.c
libavcodec/vc1dec.c
libavcodec/vdpau_h264.c
libavcodec/wmv2dec.c

diff --combined libavcodec/dxva2_h264.c
@@@ -3,26 -3,27 +3,27 @@@
   *
   * copyright (c) 2009 Laurent Aimar
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "dxva2_internal.h"
  #include "h264.h"
  #include "h264data.h"
+ #include "mpegutils.h"
  
  struct dxva2_picture_context {
      DXVA_PicParams_H264   pp;
@@@ -95,7 -96,7 +96,7 @@@ static void fill_picture_parameters(str
                                          ((h->sps.mb_aff &&
                                          (h->picture_structure == PICT_FRAME)) <<  1) |
                                          (h->sps.residual_color_transform_flag <<  2) |
 -                                        /* sp_for_switch_flag (not implemented by Libav) */
 +                                        /* sp_for_switch_flag (not implemented by FFmpeg) */
                                          (0                                    <<  3) |
                                          (h->sps.chroma_format_idc             <<  4) |
                                          ((h->nal_ref_idc != 0)                <<  6) |
      pp->bit_depth_chroma_minus8       = h->sps.bit_depth_chroma - 8;
      if (ctx->workaround & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG)
          pp->Reserved16Bits            = 0;
 +    else if (ctx->workaround & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)
 +        pp->Reserved16Bits            = 0x34c;
      else
          pp->Reserved16Bits            = 3; /* FIXME is there a way to detect the right mode ? */
      pp->StatusReportFeedbackNumber    = 1 + ctx->report_id++;
      pp->deblocking_filter_control_present_flag = h->pps.deblocking_filter_parameters_present;
      pp->redundant_pic_cnt_present_flag= h->pps.redundant_pic_cnt_present;
      pp->Reserved8BitsB                = 0;
 -    pp->slice_group_change_rate_minus1= 0;  /* XXX not implemented by Libav */
 -    //pp->SliceGroupMap[810];               /* XXX not implemented by Libav */
 +    pp->slice_group_change_rate_minus1= 0;  /* XXX not implemented by FFmpeg */
 +    //pp->SliceGroupMap[810];               /* XXX not implemented by FFmpeg */
  }
  
  static void fill_scaling_lists(struct dxva_context *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
@@@ -196,18 -195,8 +197,18 @@@ static void fill_slice_short(DXVA_Slice
      slice->wBadSliceChopping     = 0;
  }
  
 +static int get_refpic_index(const DXVA_PicParams_H264 *pp, int surface_index)
 +{
 +    int i;
 +    for (i = 0; i < FF_ARRAY_ELEMS(pp->RefFrameList); i++) {
 +        if ((pp->RefFrameList[i].bPicEntry & 0x7f) == surface_index)
 +          return i;
 +    }
 +    return 0x7f;
 +}
 +
  static void fill_slice_long(AVCodecContext *avctx, DXVA_Slice_H264_Long *slice,
 -                            unsigned position, unsigned size)
 +                            const DXVA_PicParams_H264 *pp, unsigned position, unsigned size)
  {
      const H264Context *h = avctx->priv_data;
      struct dxva_context *ctx = avctx->hwaccel_context;
          slice->num_ref_idx_l0_active_minus1 = h->ref_count[0] - 1;
      if (h->list_count > 1)
          slice->num_ref_idx_l1_active_minus1 = h->ref_count[1] - 1;
 -    slice->slice_alpha_c0_offset_div2   = h->slice_alpha_c0_offset / 2 - 26;
 -    slice->slice_beta_offset_div2       = h->slice_beta_offset     / 2 - 26;
 +    slice->slice_alpha_c0_offset_div2   = h->slice_alpha_c0_offset / 2;
 +    slice->slice_beta_offset_div2       = h->slice_beta_offset     / 2;
      slice->Reserved8Bits                = 0;
  
      for (list = 0; list < 2; list++) {
              if (list < h->list_count && i < h->ref_count[list]) {
                  const H264Picture *r = &h->ref_list[list][i];
                  unsigned plane;
 -                fill_picture_entry(&slice->RefPicList[list][i],
 -                                   ff_dxva2_get_surface_index(ctx, r),
 +                unsigned index;
 +                if (ctx->workaround & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)
 +                    index = ff_dxva2_get_surface_index(ctx, r);
 +                else
 +                    index = get_refpic_index(pp, ff_dxva2_get_surface_index(ctx, r));
 +                fill_picture_entry(&slice->RefPicList[list][i], index,
                                     r->reference == PICT_BOTTOM_FIELD);
                  for (plane = 0; plane < 3; plane++) {
                      int w, o;
              }
          }
      }
 -    slice->slice_qs_delta    = 0; /* XXX not implemented by Libav */
 +    slice->slice_qs_delta    = 0; /* XXX not implemented by FFmpeg */
      slice->slice_qp_delta    = h->qscale - h->pps.init_qp;
      slice->redundant_pic_cnt = h->redundant_pic_count;
      if (h->slice_type == AV_PICTURE_TYPE_B)
@@@ -306,7 -291,7 +307,7 @@@ static int commit_bitstream_and_slice_b
      /* Create an annex B bitstream buffer with only slice NAL and finalize slice */
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                 DXVA2_BitStreamDateBufferType,
 -                                               &dxva_data, &dxva_size)))
 +                                               (void **)&dxva_data, &dxva_size)))
          return -1;
      current = dxva_data;
      end = dxva_data + dxva_size;
@@@ -430,7 -415,7 +431,7 @@@ static int dxva2_h264_decode_slice(AVCo
                           position, size);
      else
          fill_slice_long(avctx, &ctx_pic->slice_long[ctx_pic->slice_count],
 -                        position, size);
 +                        &ctx_pic->pp, position, size);
      ctx_pic->slice_count++;
  
      if (h->slice_type != AV_PICTURE_TYPE_I && h->slice_type != AV_PICTURE_TYPE_SI)
diff --combined libavcodec/dxva2_mpeg2.c
@@@ -3,25 -3,26 +3,26 @@@
   *
   * copyright (c) 2010 Laurent Aimar
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/log.h"
  #include "dxva2_internal.h"
+ #include "mpegutils.h"
  
  #define MAX_SLICES 1024
  struct dxva2_picture_context {
@@@ -110,10 -111,10 +111,10 @@@ static void fill_quantization_matrices(
          qm->bNewQmatrix[i] = 1;
      for (i = 0; i < 64; i++) {
          int n = s->dsp.idct_permutation[ff_zigzag_direct[i]];
 -        qm->Qmatrix[0][i] = s->intra_matrix[n];;
 -        qm->Qmatrix[1][i] = s->inter_matrix[n];;
 -        qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];;
 -        qm->Qmatrix[3][i] = s->chroma_inter_matrix[n];;
 +        qm->Qmatrix[0][i] = s->intra_matrix[n];
 +        qm->Qmatrix[1][i] = s->inter_matrix[n];
 +        qm->Qmatrix[2][i] = s->chroma_intra_matrix[n];
 +        qm->Qmatrix[3][i] = s->chroma_inter_matrix[n];
      }
  }
  
@@@ -140,7 -141,8 +141,7 @@@ static void fill_slice(AVCodecContext *
      init_get_bits(&gb, &buffer[4], 8 * (size - 4));
  
      slice->wQuantizerScaleCode = get_bits(&gb, 5);
 -    while (get_bits1(&gb))
 -        skip_bits(&gb, 8);
 +    skip_1stop_8data_bits(&gb);
  
      slice->wMBbitOffset        = 4 * 8 + get_bits_count(&gb);
  }
@@@ -160,7 -162,7 +161,7 @@@ static int commit_bitstream_and_slice_b
  
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                DXVA2_BitStreamDateBufferType,
 -                                              &dxva_data, &dxva_size)))
 +                                              (void **)&dxva_data, &dxva_size)))
          return -1;
      current = dxva_data;
      end = dxva_data + dxva_size;
diff --combined libavcodec/dxva2_vc1.c
@@@ -3,24 -3,25 +3,25 @@@
   *
   * copyright (c) 2010 Laurent Aimar
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "dxva2_internal.h"
+ #include "mpegutils.h"
  #include "vc1.h"
  #include "vc1data.h"
  
@@@ -38,15 -39,6 +39,15 @@@ static void fill_picture_parameters(AVC
  {
      const MpegEncContext *s = &v->s;
      const Picture *current_picture = s->current_picture_ptr;
 +    int intcomp = 0;
 +
 +    // determine if intensity compensation is needed
 +    if (s->pict_type == AV_PICTURE_TYPE_P) {
 +      if ((v->fcm == ILACE_FRAME && v->intcomp) || (v->fcm != ILACE_FRAME && v->mv_mode == MV_PMODE_INTENSITY_COMP)) {
 +        if (v->lumscale != 32 || v->lumshift != 0 || (s->picture_structure != PICT_FRAME && (v->lumscale2 != 32 || v->lumshift2 != 0)))
 +          intcomp = 1;
 +      }
 +    }
  
      memset(pp, 0, sizeof(*pp));
      pp->wDecodedPictureIndex    =
          pp->bPicStructure      |= 0x01;
      if (s->picture_structure & PICT_BOTTOM_FIELD)
          pp->bPicStructure      |= 0x02;
 -    pp->bSecondField            = v->interlace && v->fcm != ILACE_FIELD && !s->first_field;
 +    pp->bSecondField            = v->interlace && v->fcm == ILACE_FIELD && v->second_field;
      pp->bPicIntra               = s->pict_type == AV_PICTURE_TYPE_I || v->bi_type;
      pp->bPicBackwardPrediction  = s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type;
      pp->bBidirectionalAveragingMode = (1                                           << 7) |
                                        ((ctx->cfg->ConfigIntraResidUnsigned != 0)   << 6) |
                                        ((ctx->cfg->ConfigResidDiffAccelerator != 0) << 5) |
 -                                      ((v->lumscale != 32 || v->lumshift != 0)     << 4) |
 +                                      (intcomp                                     << 4) |
                                        ((v->profile == PROFILE_ADVANCED)            << 3);
      pp->bMVprecisionAndChromaRelation = ((v->mv_mode == MV_PMODE_1MV_HPEL_BILIN) << 3) |
                                          (1                                       << 2) |
                                    (v->range_mapuv_flag << 3) |
                                    (v->range_mapuv          );
      pp->bPicBinPB               = 0;
 -    pp->bMV_RPS                 = 0;
 -    pp->bReservedBits           = 0;
 +    pp->bMV_RPS                 = (v->fcm == ILACE_FIELD && pp->bPicBackwardPrediction) ? v->refdist + 9 : 0;
 +    pp->bReservedBits           = v->pq;
      if (s->picture_structure == PICT_FRAME) {
 -        pp->wBitstreamFcodes        = v->lumscale;
 -        pp->wBitstreamPCEelements   = v->lumshift;
 +        if (intcomp) {
 +            pp->wBitstreamFcodes      = v->lumscale;
 +            pp->wBitstreamPCEelements = v->lumshift;
 +        } else {
 +            pp->wBitstreamFcodes      = 32;
 +            pp->wBitstreamPCEelements = 0;
 +        }
      } else {
          /* Syntax: (top_field_param << 8) | bottom_field_param */
 -        pp->wBitstreamFcodes        = (v->lumscale << 8) | v->lumscale;
 -        pp->wBitstreamPCEelements   = (v->lumshift << 8) | v->lumshift;
 +        if (intcomp) {
 +            pp->wBitstreamFcodes      = (v->lumscale << 8) | v->lumscale2;
 +            pp->wBitstreamPCEelements = (v->lumshift << 8) | v->lumshift2;
 +        } else {
 +            pp->wBitstreamFcodes      = (32 << 8) | 32;
 +            pp->wBitstreamPCEelements = 0;
 +        }
      }
      pp->bBitstreamConcealmentNeed   = 0;
      pp->bBitstreamConcealmentMethod = 0;
@@@ -167,8 -149,8 +168,8 @@@ static void fill_slice(AVCodecContext *
      slice->dwSliceBitsInBuffer = 8 * size;
      slice->dwSliceDataLocation = position;
      slice->bStartCodeBitOffset = 0;
 -    slice->bReservedBits       = 0;
 -    slice->wMBbitOffset        = get_bits_count(&s->gb);
 +    slice->bReservedBits       = (s->pict_type == AV_PICTURE_TYPE_B && !v->bi_type) ? v->bfraction_lut_index + 9 : 0;
 +    slice->wMBbitOffset        = v->p_frame_skipped ? 0xffff : get_bits_count(&s->gb) + (avctx->codec_id == AV_CODEC_ID_VC1 ? 32 : 0);
      slice->wNumberMBsInSlice   = s->mb_width * s->mb_height; /* XXX We assume 1 slice */
      slice->wQuantizerScaleCode = v->pq;
      slice->wBadSliceChopping   = 0;
@@@ -197,16 -179,13 +198,16 @@@ static int commit_bitstream_and_slice_b
  
      if (FAILED(IDirectXVideoDecoder_GetBuffer(ctx->decoder,
                                                DXVA2_BitStreamDateBufferType,
 -                                              &dxva_data, &dxva_size)))
 +                                              (void **)&dxva_data, &dxva_size)))
          return -1;
  
      result = data_size <= dxva_size ? 0 : -1;
      if (!result) {
 -        if (start_code_size > 0)
 +        if (start_code_size > 0) {
              memcpy(dxva_data, start_code, start_code_size);
 +            if (v->second_field)
 +                dxva_data[3] = 0x0c;
 +        }
          memcpy(dxva_data + start_code_size,
                 ctx_pic->bitstream + slice->dwSliceDataLocation, slice_size);
          if (padding > 0)
@@@ -3,20 -3,20 +3,20 @@@
   *
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -30,6 -30,7 +30,7 @@@
  #include "libavutil/internal.h"
  #include "avcodec.h"
  #include "error_resilience.h"
+ #include "mpegutils.h"
  #include "mpegvideo.h"
  #include "rectangle.h"
  #include "thread.h"
@@@ -42,7 -43,7 +43,7 @@@
  static void set_mv_strides(ERContext *s, int *mv_step, int *stride)
  {
      if (s->avctx->codec_id == AV_CODEC_ID_H264) {
 -        assert(s->quarter_sample);
 +        av_assert0(s->quarter_sample);
          *mv_step = 4;
          *stride  = s->mb_width * 4;
      } else {
@@@ -135,73 -136,11 +136,73 @@@ static void guess_dc(ERContext *s, int1
                       int h, int stride, int is_luma)
  {
      int b_x, b_y;
 +    int16_t  (*col )[4] = av_malloc(stride*h*sizeof( int16_t)*4);
 +    uint32_t (*dist)[4] = av_malloc(stride*h*sizeof(uint32_t)*4);
 +
 +    if(!col || !dist) {
 +        av_log(s->avctx, AV_LOG_ERROR, "guess_dc() is out of memory\n");
 +        goto fail;
 +    }
 +
 +    for(b_y=0; b_y<h; b_y++){
 +        int color= 1024;
 +        int distance= -1;
 +        for(b_x=0; b_x<w; b_x++){
 +            int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
 +            int error_j= s->error_status_table[mb_index_j];
 +            int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 +            if(intra_j==0 || !(error_j&ER_DC_ERROR)){
 +                color= dc[b_x + b_y*stride];
 +                distance= b_x;
 +            }
 +            col [b_x + b_y*stride][1]= color;
 +            dist[b_x + b_y*stride][1]= distance >= 0 ? b_x-distance : 9999;
 +        }
 +        color= 1024;
 +        distance= -1;
 +        for(b_x=w-1; b_x>=0; b_x--){
 +            int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
 +            int error_j= s->error_status_table[mb_index_j];
 +            int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 +            if(intra_j==0 || !(error_j&ER_DC_ERROR)){
 +                color= dc[b_x + b_y*stride];
 +                distance= b_x;
 +            }
 +            col [b_x + b_y*stride][0]= color;
 +            dist[b_x + b_y*stride][0]= distance >= 0 ? distance-b_x : 9999;
 +        }
 +    }
 +    for(b_x=0; b_x<w; b_x++){
 +        int color= 1024;
 +        int distance= -1;
 +        for(b_y=0; b_y<h; b_y++){
 +            int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
 +            int error_j= s->error_status_table[mb_index_j];
 +            int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 +            if(intra_j==0 || !(error_j&ER_DC_ERROR)){
 +                color= dc[b_x + b_y*stride];
 +                distance= b_y;
 +            }
 +            col [b_x + b_y*stride][3]= color;
 +            dist[b_x + b_y*stride][3]= distance >= 0 ? b_y-distance : 9999;
 +        }
 +        color= 1024;
 +        distance= -1;
 +        for(b_y=h-1; b_y>=0; b_y--){
 +            int mb_index_j= (b_x>>is_luma) + (b_y>>is_luma)*s->mb_stride;
 +            int error_j= s->error_status_table[mb_index_j];
 +            int intra_j = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 +            if(intra_j==0 || !(error_j&ER_DC_ERROR)){
 +                color= dc[b_x + b_y*stride];
 +                distance= b_y;
 +            }
 +            col [b_x + b_y*stride][2]= color;
 +            dist[b_x + b_y*stride][2]= distance >= 0 ? distance-b_y : 9999;
 +        }
 +    }
  
      for (b_y = 0; b_y < h; b_y++) {
          for (b_x = 0; b_x < w; b_x++) {
 -            int color[4]    = { 1024, 1024, 1024, 1024 };
 -            int distance[4] = { 9999, 9999, 9999, 9999 };
              int mb_index, error, j;
              int64_t guess, weight_sum;
              mb_index = (b_x >> is_luma) + (b_y >> is_luma) * s->mb_stride;
              if (!(error & ER_DC_ERROR))
                  continue; // dc-ok
  
 -            /* right block */
 -            for (j = b_x + 1; j < w; j++) {
 -                int mb_index_j = (j >> is_luma) + (b_y >> is_luma) * s->mb_stride;
 -                int error_j    = s->error_status_table[mb_index_j];
 -                int intra_j    = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 -                if (intra_j == 0 || !(error_j & ER_DC_ERROR)) {
 -                    color[0]    = dc[j + b_y * stride];
 -                    distance[0] = j - b_x;
 -                    break;
 -                }
 -            }
 -
 -            /* left block */
 -            for (j = b_x - 1; j >= 0; j--) {
 -                int mb_index_j = (j >> is_luma) + (b_y >> is_luma) * s->mb_stride;
 -                int error_j    = s->error_status_table[mb_index_j];
 -                int intra_j    = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 -                if (intra_j == 0 || !(error_j & ER_DC_ERROR)) {
 -                    color[1]    = dc[j + b_y * stride];
 -                    distance[1] = b_x - j;
 -                    break;
 -                }
 -            }
 -
 -            /* bottom block */
 -            for (j = b_y + 1; j < h; j++) {
 -                int mb_index_j = (b_x >> is_luma) + (j >> is_luma) * s->mb_stride;
 -                int error_j    = s->error_status_table[mb_index_j];
 -                int intra_j    = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 -
 -                if (intra_j == 0 || !(error_j & ER_DC_ERROR)) {
 -                    color[2]    = dc[b_x + j * stride];
 -                    distance[2] = j - b_y;
 -                    break;
 -                }
 -            }
 -
 -            /* top block */
 -            for (j = b_y - 1; j >= 0; j--) {
 -                int mb_index_j = (b_x >> is_luma) + (j >> is_luma) * s->mb_stride;
 -                int error_j    = s->error_status_table[mb_index_j];
 -                int intra_j    = IS_INTRA(s->cur_pic.mb_type[mb_index_j]);
 -                if (intra_j == 0 || !(error_j & ER_DC_ERROR)) {
 -                    color[3]    = dc[b_x + j * stride];
 -                    distance[3] = b_y - j;
 -                    break;
 -                }
 -            }
 -
              weight_sum = 0;
              guess      = 0;
              for (j = 0; j < 4; j++) {
 -                int64_t weight  = 256 * 256 * 256 * 16 / distance[j];
 -                guess          += weight * (int64_t) color[j];
 +                int64_t weight  = 256 * 256 * 256 * 16 / FFMAX(dist[b_x + b_y*stride][j], 1);
 +                guess          += weight*(int64_t)col[b_x + b_y*stride][j];
                  weight_sum     += weight;
              }
              guess = (guess + weight_sum / 2) / weight_sum;
              dc[b_x + b_y * stride] = guess;
          }
      }
 +
 +fail:
 +    av_freep(&col);
 +    av_freep(&dist);
  }
  
  /**
@@@ -396,14 -380,6 +397,14 @@@ static void guess_mv(ERContext *s
          fixed[mb_xy] = f;
          if (f == MV_FROZEN)
              num_avail++;
 +        else if(s->last_pic.f->data[0] && s->last_pic.motion_val[0]){
 +            const int mb_y= mb_xy / s->mb_stride;
 +            const int mb_x= mb_xy % s->mb_stride;
 +            const int mot_index= (mb_x + mb_y*mot_stride) * mot_step;
 +            s->cur_pic.motion_val[0][mot_index][0]= s->last_pic.motion_val[0][mot_index][0];
 +            s->cur_pic.motion_val[0][mot_index][1]= s->last_pic.motion_val[0][mot_index][1];
 +            s->cur_pic.ref_index[0][4*mb_xy]      = s->last_pic.ref_index[0][4*mb_xy];
 +        }
      }
  
      if ((!(s->avctx->error_concealment&FF_EC_GUESS_MVS)) ||
  
                      if (fixed[mb_xy] == MV_FROZEN)
                          continue;
 -                    assert(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
 -                    assert(s->last_pic && s->last_pic.f->data[0]);
 +                    av_assert1(!IS_INTRA(s->cur_pic.mb_type[mb_xy]));
 +                    av_assert1(s->last_pic.f && s->last_pic.f->data[0]);
  
                      j = 0;
                      if (mb_x > 0             && fixed[mb_xy - 1]         == MV_FROZEN)
@@@ -570,7 -546,7 +571,7 @@@ skip_mean_and_median
                      /* zero MV */
                      pred_count++;
  
 -                    if (!fixed[mb_xy]) {
 +                    if (!fixed[mb_xy] && 0) {
                          if (s->avctx->codec_id == AV_CODEC_ID_H264) {
                              // FIXME
                          } else {
@@@ -699,11 -675,15 +700,11 @@@ static int is_intra_more_likely(ERConte
      if (undamaged_count < 5)
          return 0; // almost all MBs damaged -> use temporal prediction
  
 -#if FF_API_XVMC
 -FF_DISABLE_DEPRECATION_WARNINGS
      // prevent dsp.sad() check, that requires access to the image
 -    if (CONFIG_MPEG_XVMC_DECODER    &&
 -        s->avctx->xvmc_acceleration &&
 +    if (CONFIG_XVMC    &&
 +        s->avctx->hwaccel && s->avctx->hwaccel->decode_mb &&
          s->cur_pic.f->pict_type == AV_PICTURE_TYPE_I)
          return 1;
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif /* FF_API_XVMC */
  
      skip_amount     = FFMAX(undamaged_count / 50, 1); // check only up to 50 MBs
      is_intra_likely = 0;
                  }
                  is_intra_likely += s->dsp->sad[0](NULL, last_mb_ptr, mb_ptr,
                                                   linesize[0], 16);
 +                // FIXME need await_progress() here
                  is_intra_likely -= s->dsp->sad[0](NULL, last_mb_ptr,
                                                   last_mb_ptr + linesize[0] * 16,
                                                   linesize[0], 16);
              }
          }
      }
 +//      av_log(NULL, AV_LOG_ERROR, "is_intra_likely: %d type:%d\n", is_intra_likely, s->pict_type);
      return is_intra_likely > 0;
  }
  
@@@ -764,17 -742,6 +765,17 @@@ void ff_er_frame_start(ERContext *s
      s->error_occurred = 0;
  }
  
 +static int er_supported(ERContext *s)
 +{
 +    if(s->avctx->hwaccel && s->avctx->hwaccel->decode_slice           ||
 +       s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU          ||
 +       !s->cur_pic.f                                                  ||
 +       s->cur_pic.field_picture
 +    )
 +        return 0;
 +    return 1;
 +}
 +
  /**
   * Add a slice.
   * @param endx   x component of the last macroblock, can be -1
@@@ -791,7 -758,7 +792,7 @@@ void ff_er_add_slice(ERContext *s, int 
      const int end_xy   = s->mb_index2xy[end_i];
      int mask           = -1;
  
 -    if (s->avctx->hwaccel)
 +    if (s->avctx->hwaccel && s->avctx->hwaccel->decode_slice)
          return;
  
      if (start_i > end_i || start_xy > end_xy) {
  
      s->error_status_table[start_xy] |= VP_START;
  
 -    if (start_xy > 0 && s->avctx->thread_count <= 1 &&
 -        s->avctx->skip_top * s->mb_width < start_i) {
 +    if (start_xy > 0 && !(s->avctx->active_thread_type & FF_THREAD_SLICE) &&
 +        er_supported(s) && s->avctx->skip_top * s->mb_width < start_i) {
          int prev_status = s->error_status_table[s->mb_index2xy[start_i - 1]];
  
          prev_status &= ~ VP_START;
 -        if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
 +        if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END)) {
 +            s->error_occurred = 1;
              s->error_count = INT_MAX;
 +        }
      }
  }
  
@@@ -865,66 -830,19 +866,66 @@@ void ff_er_frame_end(ERContext *s
      /* We do not support ER of field pictures yet,
       * though it should not crash if enabled. */
      if (!s->avctx->error_concealment || s->error_count == 0            ||
 -        s->avctx->hwaccel                                              ||
 -        !s->cur_pic.f                                                  ||
 -        s->cur_pic.field_picture                                       ||
 +        s->avctx->lowres                                               ||
 +        !er_supported(s)                                               ||
          s->error_count == 3 * s->mb_width *
                            (s->avctx->skip_top + s->avctx->skip_bottom)) {
          return;
 -    };
 +    }
 +    for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
 +        int status = s->error_status_table[mb_x + (s->mb_height - 1) * s->mb_stride];
 +        if (status != 0x7F)
 +            break;
 +    }
  
 -    if (!s->cur_pic.motion_val[0] || !s->cur_pic.ref_index[0]) {
 -        av_log(s->avctx, AV_LOG_ERROR, "MVs not available, ER not possible.\n");
 +    if (   mb_x == s->mb_width
 +        && s->avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO
 +        && (s->avctx->height&16)
 +        && s->error_count == 3 * s->mb_width * (s->avctx->skip_top + s->avctx->skip_bottom + 1)
 +    ) {
 +        av_log(s->avctx, AV_LOG_DEBUG, "ignoring last missing slice\n");
          return;
      }
  
 +    if (s->last_pic.f) {
 +        if (s->last_pic.f->width  != s->cur_pic.f->width  ||
 +            s->last_pic.f->height != s->cur_pic.f->height ||
 +            s->last_pic.f->format != s->cur_pic.f->format) {
 +            av_log(s->avctx, AV_LOG_WARNING, "Cannot use previous picture in error concealment\n");
 +            memset(&s->last_pic, 0, sizeof(s->last_pic));
 +        }
 +    }
 +    if (s->next_pic.f) {
 +        if (s->next_pic.f->width  != s->cur_pic.f->width  ||
 +            s->next_pic.f->height != s->cur_pic.f->height ||
 +            s->next_pic.f->format != s->cur_pic.f->format) {
 +            av_log(s->avctx, AV_LOG_WARNING, "Cannot use next picture in error concealment\n");
 +            memset(&s->next_pic, 0, sizeof(s->next_pic));
 +        }
 +    }
 +
 +    if (!s->cur_pic.motion_val[0] || !s->cur_pic.ref_index[0]) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Warning MVs not available\n");
 +
 +        for (i = 0; i < 2; i++) {
 +            s->ref_index_buf[i]  = av_buffer_allocz(s->mb_stride * s->mb_height * 4 * sizeof(uint8_t));
 +            s->motion_val_buf[i] = av_buffer_allocz((size + 4) * 2 * sizeof(uint16_t));
 +            if (!s->ref_index_buf[i] || !s->motion_val_buf[i])
 +                break;
 +            s->cur_pic.ref_index[i]  = s->ref_index_buf[i]->data;
 +            s->cur_pic.motion_val[i] = (int16_t (*)[2])s->motion_val_buf[i]->data + 4;
 +        }
 +        if (i < 2) {
 +            for (i = 0; i < 2; i++) {
 +                av_buffer_unref(&s->ref_index_buf[i]);
 +                av_buffer_unref(&s->motion_val_buf[i]);
 +                s->cur_pic.ref_index[i]  = NULL;
 +                s->cur_pic.motion_val[i] = NULL;
 +            }
 +            return;
 +        }
 +    }
 +
      if (s->avctx->debug & FF_DEBUG_ER) {
          for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
              for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
          }
      }
  
 +#if 1
      /* handle overlapping slices */
      for (error_type = 1; error_type <= 3; error_type++) {
          int end_ok = 0;
                  end_ok = 0;
          }
      }
 -
 +#endif
 +#if 1
      /* handle slices with partitions of different length */
      if (s->partitioned_frame) {
          int end_ok = 0;
                  end_ok = 0;
          }
      }
 -
 +#endif
      /* handle missing slices */
      if (s->avctx->err_recognition & AV_EF_EXPLODE) {
          int end_ok = 1;
          }
      }
  
 +#if 1
      /* backward mark errors */
      distance = 9999999;
      for (error_type = 1; error_type <= 3; error_type++) {
                  distance = 9999999;
          }
      }
 +#endif
  
      /* forward mark errors */
      error = 0;
              s->error_status_table[mb_xy] |= error;
          }
      }
 -
 +#if 1
      /* handle not partitioned case */
      if (!s->partitioned_frame) {
          for (i = 0; i < s->mb_num; i++) {
              s->error_status_table[mb_xy] = error;
          }
      }
 +#endif
  
      dc_error = ac_error = mv_error = 0;
      for (i = 0; i < s->mb_num; i++) {
          if (error & ER_MV_ERROR)
              mv_error++;
      }
 -    av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors\n",
 -           dc_error, ac_error, mv_error);
 +    av_log(s->avctx, AV_LOG_INFO, "concealing %d DC, %d AC, %d MV errors in %c frame\n",
 +           dc_error, ac_error, mv_error, av_get_picture_type_char(s->cur_pic.f->pict_type));
  
      is_intra_likely = is_intra_more_likely(s);
  
                      int time_pp = s->pp_time;
                      int time_pb = s->pb_time;
  
 +                    av_assert0(s->avctx->codec_id != AV_CODEC_ID_H264);
                      ff_thread_await_progress(s->next_pic.tf, mb_y, 0);
  
                      s->mv[0][0][0] = s->next_pic.motion_val[0][xy][0] *  time_pb            / time_pp;
      } else
          guess_mv(s);
  
 -#if FF_API_XVMC
 -FF_DISABLE_DEPRECATION_WARNINGS
 -    /* the filters below are not XvMC compatible, skip them */
 -    if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
 +    /* the filters below manipulate raw image, skip them */
 +    if (CONFIG_XVMC && s->avctx->hwaccel && s->avctx->hwaccel->decode_mb)
          goto ec_clean;
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif /* FF_API_XVMC */
      /* fill DC for inter blocks */
      for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
          for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
              s->dc_val[2][mb_x + mb_y * s->mb_stride] = (dcv + 4) >> 3;
          }
      }
 -
 +#if 1
      /* guess DC for damaged blocks */
 -    guess_dc(s, s->dc_val[0], s->mb_width * 2, s->mb_height * 2, s->b8_stride, 1);
 -    guess_dc(s, s->dc_val[1], s->mb_width, s->mb_height, s->mb_stride, 0);
 -    guess_dc(s, s->dc_val[2], s->mb_width, s->mb_height, s->mb_stride, 0);
 +    guess_dc(s, s->dc_val[0], s->mb_width*2, s->mb_height*2, s->b8_stride, 1);
 +    guess_dc(s, s->dc_val[1], s->mb_width  , s->mb_height  , s->mb_stride, 0);
 +    guess_dc(s, s->dc_val[2], s->mb_width  , s->mb_height  , s->mb_stride, 0);
 +#endif
  
      /* filter luma DC */
      filter181(s->dc_val[0], s->mb_width * 2, s->mb_height * 2, s->b8_stride);
  
 +#if 1
      /* render DC only intra */
      for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
          for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
              put_dc(s, dest_y, dest_cb, dest_cr, mb_x, mb_y);
          }
      }
 +#endif
  
      if (s->avctx->error_concealment & FF_EC_DEBLOCK) {
          /* filter horizontal block boundaries */
@@@ -1296,13 -1209,6 +1297,13 @@@ ec_clean
          s->mbintra_table[mb_xy] = 1;
      }
  
 +    for (i = 0; i < 2; i++) {
 +        av_buffer_unref(&s->ref_index_buf[i]);
 +        av_buffer_unref(&s->motion_val_buf[i]);
 +        s->cur_pic.ref_index[i]  = NULL;
 +        s->cur_pic.motion_val[i] = NULL;
 +    }
 +
      memset(&s->cur_pic, 0, sizeof(ERPicture));
      memset(&s->last_pic, 0, sizeof(ERPicture));
      memset(&s->next_pic, 0, sizeof(ERPicture));
diff --combined libavcodec/h261dec.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   * Copyright (c) 2004 Maarten Daniels
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -25,8 -25,8 +25,9 @@@
   * H.261 decoder.
   */
  
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
+ #include "mpegutils.h"
  #include "mpegvideo.h"
  #include "h263.h"
  #include "h261.h"
@@@ -126,12 -126,12 +127,12 @@@ static int h261_decode_gob_header(H261C
      }
  
      /* GEI */
 -    while (get_bits1(&s->gb) != 0)
 -        skip_bits(&s->gb, 8);
 +    if (skip_1stop_8data_bits(&s->gb) < 0)
 +        return AVERROR_INVALIDDATA;
  
      if (s->qscale == 0) {
          av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
 -        if (s->avctx->err_recognition & AV_EF_BITSTREAM)
 +        if (s->avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
              return -1;
      }
  
@@@ -378,12 -378,11 +379,12 @@@ static int h261_decode_mb(H261Context *
  
      // Read mtype
      h->mtype = get_vlc2(&s->gb, h261_mtype_vlc.table, H261_MTYPE_VLC_BITS, 2);
 -    if (h->mtype < 0 || h->mtype >= FF_ARRAY_ELEMS(ff_h261_mtype_map)) {
 +    if (h->mtype < 0) {
          av_log(s->avctx, AV_LOG_ERROR, "Invalid mtype index %d\n",
                 h->mtype);
          return SLICE_ERROR;
      }
 +    av_assert0(h->mtype < FF_ARRAY_ELEMS(ff_h261_mtype_map));
      h->mtype = ff_h261_mtype_map[h->mtype];
  
      // Read mquant
@@@ -506,8 -505,8 +507,8 @@@ static int h261_decode_picture_header(H
      skip_bits1(&s->gb); /* Reserved */
  
      /* PEI */
 -    while (get_bits1(&s->gb) != 0)
 -        skip_bits(&s->gb, 8);
 +    if (skip_1stop_8data_bits(&s->gb) < 0)
 +        return AVERROR_INVALIDDATA;
  
      /* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
       * frame, the codec crashes if it does not contain all I-blocks
@@@ -633,12 -632,12 +634,12 @@@ retry
      }
      ff_MPV_frame_end(s);
  
 -    assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
 -    assert(s->current_picture.f.pict_type == s->pict_type);
 +    av_assert0(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
 +    av_assert0(s->current_picture.f.pict_type == s->pict_type);
  
      if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
          return ret;
 -    ff_print_debug_info(s, s->current_picture_ptr);
 +    ff_print_debug_info(s, s->current_picture_ptr, pict);
  
      *got_frame = 1;
  
@@@ -664,5 -663,4 +665,5 @@@ AVCodec ff_h261_decoder = 
      .close          = h261_decode_end,
      .decode         = h261_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
 +    .max_lowres     = 3,
  };
diff --combined libavcodec/h261enc.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   * Copyright (c) 2004 Maarten Daniels
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   */
  
  #include "libavutil/attributes.h"
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
+ #include "mpegutils.h"
  #include "mpegvideo.h"
  #include "h263.h"
  #include "h261.h"
  
 +static uint8_t uni_h261_rl_len [64*64*2*2];
 +#define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
 +
  int ff_h261_get_picture_format(int width, int height)
  {
      // QCIF
@@@ -80,7 -77,7 +81,7 @@@ void ff_h261_encode_picture_header(Mpeg
          h->gob_number = -1;
      else
          h->gob_number = 0;
 -    h->current_mba = 0;
 +    s->mb_skip_run = 0;
  }
  
  /**
@@@ -98,21 -95,18 +99,21 @@@ static void h261_encode_gob_header(Mpeg
      put_bits(&s->pb, 4, h->gob_number); /* GN */
      put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
      put_bits(&s->pb, 1, 0);             /* no GEI */
 -    h->current_mba  = 0;
 -    h->previous_mba = 0;
 -    h->current_mv_x = 0;
 -    h->current_mv_y = 0;
 +    s->mb_skip_run = 0;
 +    s->last_mv[0][0][0] = 0;
 +    s->last_mv[0][0][1] = 0;
  }
  
  void ff_h261_reorder_mb_index(MpegEncContext *s)
  {
      int index = s->mb_x + s->mb_y * s->mb_width;
  
 -    if (index % 33 == 0)
 -        h261_encode_gob_header(s, 0);
 +    if (index % 11 == 0) {
 +        if (index % 33 == 0)
 +            h261_encode_gob_header(s, 0);
 +        s->last_mv[0][0][0] = 0;
 +        s->last_mv[0][0][1] = 0;
 +    }
  
      /* for CIF the GOB's are fragmented in the middle of a scanline
       * that's why we need to adjust the x and y index of the macroblocks */
@@@ -219,8 -213,8 +220,8 @@@ static void h261_encode_block(H261Conte
              put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
              if (code == rl->n) {
                  put_bits(&s->pb, 6, run);
 -                assert(slevel != 0);
 -                assert(level <= 127);
 +                av_assert1(slevel != 0);
 +                av_assert1(level <= 127);
                  put_sbits(&s->pb, 8, slevel);
              } else {
                  put_bits(&s->pb, 1, sign);
@@@ -240,6 -234,7 +241,6 @@@ void ff_h261_encode_mb(MpegEncContext *
      cbp = 63; // avoid warning
      mvd = 0;
  
 -    h->current_mba++;
      h->mtype = 0;
  
      if (!s->mb_intra) {
          if ((cbp | mvd | s->dquant) == 0) {
              /* skip macroblock */
              s->skip_count++;
 -            h->current_mv_x = 0;
 -            h->current_mv_y = 0;
 +            s->mb_skip_run++;
 +            s->last_mv[0][0][0] = 0;
 +            s->last_mv[0][0][1] = 0;
              return;
          }
      }
  
      /* MB is not skipped, encode MBA */
      put_bits(&s->pb,
 -             ff_h261_mba_bits[(h->current_mba - h->previous_mba) - 1],
 -             ff_h261_mba_code[(h->current_mba - h->previous_mba) - 1]);
 +             ff_h261_mba_bits[s->mb_skip_run],
 +             ff_h261_mba_code[s->mb_skip_run]);
 +    s->mb_skip_run = 0;
  
      /* calculate MTYPE */
      if (!s->mb_intra) {
              h->mtype += 3;
          if (cbp || s->dquant)
              h->mtype++;
 -        assert(h->mtype > 1);
 +        av_assert1(h->mtype > 1);
      }
  
      if (s->dquant)
      }
  
      if (IS_16X16(h->mtype)) {
 -        mv_diff_x       = (motion_x >> 1) - h->current_mv_x;
 -        mv_diff_y       = (motion_y >> 1) - h->current_mv_y;
 -        h->current_mv_x = (motion_x >> 1);
 -        h->current_mv_y = (motion_y >> 1);
 +        mv_diff_x       = (motion_x >> 1) - s->last_mv[0][0][0];
 +        mv_diff_y       = (motion_y >> 1) - s->last_mv[0][0][1];
 +        s->last_mv[0][0][0] = (motion_x >> 1);
 +        s->last_mv[0][0][1] = (motion_y >> 1);
          h261_encode_motion(h, mv_diff_x);
          h261_encode_motion(h, mv_diff_y);
      }
  
 -    h->previous_mba = h->current_mba;
 -
      if (HAS_CBP(h->mtype)) {
 -        assert(cbp > 0);
 +        av_assert1(cbp > 0);
          put_bits(&s->pb,
                   ff_h261_cbp_tab[cbp - 1][1],
                   ff_h261_cbp_tab[cbp - 1][0]);
          /* encode each block */
          h261_encode_block(h, block[i], i);
  
 -    if ((h->current_mba == 11) || (h->current_mba == 22) ||
 -        (h->current_mba == 33) || (!IS_16X16(h->mtype))) {
 -        h->current_mv_x = 0;
 -        h->current_mv_y = 0;
 +    if (!IS_16X16(h->mtype)) {
 +        s->last_mv[0][0][0] = 0;
 +        s->last_mv[0][0][1] = 0;
 +    }
 +}
 +
 +static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab,
 +                                         uint8_t *len_tab)
 +{
 +    int slevel, run, last;
 +
 +    av_assert0(MAX_LEVEL >= 64);
 +    av_assert0(MAX_RUN   >= 63);
 +
 +    for(slevel=-64; slevel<64; slevel++){
 +        if(slevel==0) continue;
 +        for(run=0; run<64; run++){
 +            for(last=0; last<=1; last++){
 +                const int index= UNI_ENC_INDEX(last, run, slevel+64);
 +                int level= slevel < 0 ? -slevel : slevel;
 +                int len, code;
 +
 +                len_tab[index]= 100;
 +
 +                /* ESC0 */
 +                code= get_rl_index(rl, 0, run, level);
 +                len=  rl->table_vlc[code][1] + 1;
 +                if(last)
 +                    len += 2;
 +
 +                if(code!=rl->n && len < len_tab[index]){
 +                    len_tab [index]= len;
 +                }
 +                /* ESC */
 +                len = rl->table_vlc[rl->n][1];
 +                if(last)
 +                    len += 2;
 +
 +                if(len < len_tab[index]){
 +                    len_tab [index]= len;
 +                }
 +            }
 +        }
      }
  }
  
@@@ -365,12 -321,6 +366,12 @@@ av_cold void ff_h261_encode_init(MpegEn
      s->max_qcoeff       = 127;
      s->y_dc_scale_table =
      s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 +    s->ac_esc_length    = 6+6+8;
 +
 +    init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, NULL, uni_h261_rl_len);
 +
 +    s->intra_ac_vlc_length      = s->inter_ac_vlc_length      = uni_h261_rl_len;
 +    s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
  }
  
  FF_MPV_GENERIC_CLASS(h261)
diff --combined libavcodec/h263.c
@@@ -5,20 -5,20 +5,20 @@@
   * Copyright (c) 2001 Juan J. Sierralta P
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -34,6 -34,7 +34,7 @@@
  #include "h263.h"
  #include "h263data.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "unary.h"
  #include "flv.h"
  #include "mpeg4video.h"
diff --combined libavcodec/h264.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... decoder
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
 +
  #include "libavutil/avassert.h"
  #include "libavutil/imgutils.h"
 +#include "libavutil/opt.h"
  #include "libavutil/stereo3d.h"
  #include "libavutil/timer.h"
  #include "internal.h"
  #include "h264_mvpred.h"
  #include "golomb.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "rectangle.h"
  #include "svq3.h"
  #include "thread.h"
 +#include "vdpau_internal.h"
  
  #include <assert.h>
  
 +static void flush_change(H264Context *h);
 +
  const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
  
  static const uint8_t rem6[QP_MAX_NUM + 1] = {
      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,
 +    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,
  };
  
  static const uint8_t div6[QP_MAX_NUM + 1] = {
      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,
 +    7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10,
 +   10,10,10,11,11,11,11,11,11,12,12,12,12,12,12,13,13,13, 13, 13, 13,
 +   14,14,14,14,
  };
  
 -static const uint8_t field_scan[16] = {
 +static const uint8_t field_scan[16+1] = {
      0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
      0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
      2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
      3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
  };
  
 -static const uint8_t field_scan8x8[64] = {
 +static const uint8_t field_scan8x8[64+1] = {
      0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
      1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
      2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
@@@ -98,7 -89,7 +99,7 @@@
      7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
  };
  
 -static const uint8_t field_scan8x8_cavlc[64] = {
 +static const uint8_t field_scan8x8_cavlc[64+1] = {
      0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
      2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
      3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
  };
  
  // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
 -static const uint8_t zigzag_scan8x8_cavlc[64] = {
 +static const uint8_t zigzag_scan8x8_cavlc[64+1] = {
      0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
      4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
      3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
@@@ -193,12 -184,6 +194,12 @@@ static const enum AVPixelFormat h264_hw
      AV_PIX_FMT_NONE
  };
  
 +int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
 +{
 +    H264Context *h = avctx->priv_data;
 +    return h ? h->sps.num_reorder_frames : 0;
 +}
 +
  static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
                                int (*mv)[2][4][2],
                                int mb_x, int mb_y, int mb_intra, int mb_skipped)
      h->mb_y  = mb_y;
      h->mb_xy = mb_x + mb_y * h->mb_stride;
      memset(h->non_zero_count_cache, 0, sizeof(h->non_zero_count_cache));
 -    assert(ref >= 0);
 +    av_assert1(ref >= 0);
      /* FIXME: It is possible albeit uncommon that slice references
       * differ between slices. We take the easy approach and ignore
       * it for now. If this turns out to have any relevance in
       * practice then correct remapping should be added. */
      if (ref >= h->ref_count[0])
          ref = 0;
 +    if (!h->ref_list[0][ref].f.data[0]) {
 +        av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
 +        ref = 0;
 +    }
 +    if ((h->ref_list[0][ref].reference&3) != 3) {
 +        av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
 +        return;
 +    }
      fill_rectangle(&h->cur_pic.ref_index[0][4 * h->mb_xy],
                     2, 2, 2, ref, 1);
      fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
      fill_rectangle(h->mv_cache[0][scan8[0]], 4, 4, 8,
                     pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
 -    assert(!FRAME_MBAFF(h));
 +    h->mb_mbaff =
 +    h->mb_field_decoding_flag = 0;
      ff_h264_hl_decode_mb(h);
  }
  
@@@ -363,11 -339,7 +364,11 @@@ static int ref_picture(H264Context *h, 
      dst->field_picture = src->field_picture;
      dst->needs_realloc = src->needs_realloc;
      dst->reference     = src->reference;
 +    dst->crop          = src->crop;
 +    dst->crop_left     = src->crop_left;
 +    dst->crop_top      = src->crop_top;
      dst->recovered     = src->recovered;
 +    dst->invalid_gap   = src->invalid_gap;
  
      return 0;
  fail:
@@@ -437,9 -409,6 +438,9 @@@ static int alloc_picture(H264Context *h
  
      h->linesize   = pic->f.linesize[0];
      h->uvlinesize = pic->f.linesize[1];
 +    pic->crop     = h->sps.crop;
 +    pic->crop_top = h->sps.crop_top;
 +    pic->crop_left= h->sps.crop_left;
  
      if (h->avctx->hwaccel) {
          const AVHWAccel *hwaccel = h->avctx->hwaccel;
              pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
          }
      }
 +    if (!h->avctx->hwaccel && CONFIG_GRAY && h->flags & CODEC_FLAG_GRAY && pic->f.data[2]) {
 +        int h_chroma_shift, v_chroma_shift;
 +        av_pix_fmt_get_chroma_sub_sample(pic->f.format,
 +                                         &h_chroma_shift, &v_chroma_shift);
 +
 +        for(i=0; i<FF_CEIL_RSHIFT(h->avctx->height, v_chroma_shift); i++) {
 +            memset(pic->f.data[1] + pic->f.linesize[1]*i,
 +                   0x80, FF_CEIL_RSHIFT(h->avctx->width, h_chroma_shift));
 +            memset(pic->f.data[2] + pic->f.linesize[2]*i,
 +                   0x80, FF_CEIL_RSHIFT(h->avctx->width, h_chroma_shift));
 +        }
 +    }
  
      if (!h->qscale_table_pool) {
          ret = init_table_pools(h);
@@@ -675,27 -632,21 +676,27 @@@ const uint8_t *ff_h264_decode_nal(H264C
      }
  #endif
  
 -    if (i >= length - 1) { // no escaped 0
 -        *dst_length = length;
 -        *consumed   = length + 1; // +1 for the header
 -        return src;
 -    }
 -
      // use second escape buffer for inter data
      bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0;
 -    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx],
 -                   length + FF_INPUT_BUFFER_PADDING_SIZE);
 +
 +    si = h->rbsp_buffer_size[bufidx];
 +    av_fast_padded_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+MAX_MBPAIR_SIZE);
      dst = h->rbsp_buffer[bufidx];
  
      if (dst == NULL)
          return NULL;
  
 +    if(i>=length-1){ //no escaped 0
 +        *dst_length= length;
 +        *consumed= length+1; //+1 for the header
 +        if(h->avctx->flags2 & CODEC_FLAG2_FAST){
 +            return src;
 +        }else{
 +            memcpy(dst, src, length);
 +            return dst;
 +        }
 +    }
 +
      memcpy(dst, src, i);
      si = di = i;
      while (si + 2 < length) {
@@@ -751,13 -702,13 +752,13 @@@ static inline int get_lowest_part_list_
                                           int height, int y_offset, int list)
  {
      int raw_my             = h->mv_cache[list][scan8[n]][1];
 -    int filter_height_up   = (raw_my & 3) ? 2 : 0;
      int filter_height_down = (raw_my & 3) ? 3 : 0;
      int full_my            = (raw_my >> 2) + y_offset;
 -    int top                = full_my - filter_height_up;
      int bottom             = full_my + filter_height_down + height;
  
 -    return FFMAX(abs(top), bottom);
 +    av_assert2(height >= 0);
 +
 +    return FFMAX(0, bottom);
  }
  
  static inline void get_lowest_part_y(H264Context *h, int refs[2][48], int n,
@@@ -829,7 -780,7 +830,7 @@@ static void await_references(H264Contex
      } else {
          int i;
  
 -        assert(IS_8X8(mb_type));
 +        av_assert2(IS_8X8(mb_type));
  
          for (i = 0; i < 4; i++) {
              const int sub_mb_type = h->sub_mb_type[i];
                                    nrefs);
              } else {
                  int j;
 -                assert(IS_SUB_4X4(sub_mb_type));
 +                av_assert2(IS_SUB_4X4(sub_mb_type));
                  for (j = 0; j < 4; j++) {
                      int sub_y_offset = y_offset + 2 * (j & 2);
                      get_lowest_part_y(h, refs, n + j, 4, sub_y_offset,
@@@ -1198,7 -1149,9 +1199,7 @@@ static av_always_inline void prefetch_m
              h->vdsp.prefetch(src[1] + off, h->linesize, 4);
              h->vdsp.prefetch(src[2] + off, h->linesize, 4);
          } else {
 -            off = ((mx >> 1) << pixel_shift) +
 -                  ((my >> 1) + (h->mb_x & 7)) * h->uvlinesize +
 -                  (64 << pixel_shift);
 +            off= (((mx>>1)+64)<<pixel_shift) + ((my>>1) + (h->mb_x&7))*h->uvlinesize;
              h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
          }
      }
@@@ -1322,8 -1275,6 +1323,8 @@@ static void init_dequant_tables(H264Con
  {
      int i, x;
      init_dequant4_coeff_table(h);
 +    memset(h->dequant8_coeff, 0, sizeof(h->dequant8_coeff));
 +
      if (h->pps.transform_8x8_mode)
          init_dequant8_coeff_table(h);
      if (h->sps.transform_bypass) {
  int ff_h264_alloc_tables(H264Context *h)
  {
      const int big_mb_num = h->mb_stride * (h->mb_height + 1);
 -    const int row_mb_num = h->mb_stride * 2 * h->avctx->thread_count;
 +    const int row_mb_num = 2*h->mb_stride*FFMAX(h->avctx->thread_count, 1);
      int x, y, i;
  
      FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
@@@ -1499,23 -1450,20 +1500,23 @@@ fail
  static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
                              int parse_extradata);
  
 -int ff_h264_decode_extradata(H264Context *h)
 +int ff_h264_decode_extradata(H264Context *h, const uint8_t *buf, int size)
  {
      AVCodecContext *avctx = h->avctx;
      int ret;
  
 -    if (avctx->extradata[0] == 1) {
 +    if (!buf || size <= 0)
 +        return -1;
 +
 +    if (buf[0] == 1) {
          int i, cnt, nalsize;
 -        unsigned char *p = avctx->extradata;
 +        const unsigned char *p = buf;
  
          h->is_avc = 1;
  
 -        if (avctx->extradata_size < 7) {
 +        if (size < 7) {
              av_log(avctx, AV_LOG_ERROR,
 -                   "avcC %d too short\n", avctx->extradata_size);
 +                   "avcC %d too short\n", size);
              return AVERROR_INVALIDDATA;
          }
          /* sps and pps in the avcC always have length coded with 2 bytes,
          p  += 6;
          for (i = 0; i < cnt; i++) {
              nalsize = AV_RB16(p) + 2;
 -            if (p - avctx->extradata + nalsize > avctx->extradata_size)
 +            if(nalsize > size - (p-buf))
                  return AVERROR_INVALIDDATA;
              ret = decode_nal_units(h, p, nalsize, 1);
              if (ret < 0) {
          cnt = *(p++); // Number of pps
          for (i = 0; i < cnt; i++) {
              nalsize = AV_RB16(p) + 2;
 -            if (p - avctx->extradata + nalsize > avctx->extradata_size)
 +            if(nalsize > size - (p-buf))
                  return AVERROR_INVALIDDATA;
              ret = decode_nal_units(h, p, nalsize, 1);
              if (ret < 0) {
              p += nalsize;
          }
          // Now store right nal length size, that will be used to parse all other nals
 -        h->nal_length_size = (avctx->extradata[4] & 0x03) + 1;
 +        h->nal_length_size = (buf[4] & 0x03) + 1;
      } else {
          h->is_avc = 0;
 -        ret = decode_nal_units(h, avctx->extradata, avctx->extradata_size, 1);
 +        ret = decode_nal_units(h, buf, size, 1);
          if (ret < 0)
              return ret;
      }
 -    return 0;
 +    return size;
  }
  
  av_cold int ff_h264_decode_init(AVCodecContext *avctx)
      h->bit_depth_luma    = 8;
      h->chroma_format_idc = 1;
  
 +    h->avctx->bits_per_raw_sample = 8;
 +    h->cur_chroma_format_idc = 1;
 +
      ff_h264dsp_init(&h->h264dsp, 8, 1);
 +    av_assert0(h->sps.bit_depth_chroma == 0);
      ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
      ff_h264qpel_init(&h->h264qpel, 8);
      ff_h264_pred_init(&h->hpc, h->avctx->codec_id, 8, 1);
  
      h->dequant_coeff_pps = -1;
 +    h->current_sps_id = -1;
  
      /* needed so that IDCT permutation is known early */
      if (CONFIG_ERROR_RESILIENCE)
      for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
          h->last_pocs[i] = INT_MIN;
      h->prev_poc_msb = 1 << 16;
 +    h->prev_frame_num = -1;
      h->x264_build   = -1;
 +    h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
      ff_h264_reset_sei(h);
 -    h->recovery_frame = -1;
 -    h->frame_recovered = 0;
      if (avctx->codec_id == AV_CODEC_ID_H264) {
 -        if (avctx->ticks_per_frame == 1)
 -            h->avctx->time_base.den *= 2;
 +        if (avctx->ticks_per_frame == 1) {
 +            if(h->avctx->time_base.den < INT_MAX/2) {
 +                h->avctx->time_base.den *= 2;
 +            } else
 +                h->avctx->time_base.num /= 2;
 +        }
          avctx->ticks_per_frame = 2;
      }
  
      if (avctx->extradata_size > 0 && avctx->extradata) {
 -       ret = ff_h264_decode_extradata(h);
 -       if (ret < 0)
 -           return ret;
 +        ret = ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);
 +        if (ret < 0) {
 +            ff_h264_free_context(h);
 +            return ret;
 +        }
      }
  
      if (h->sps.bitstream_restriction_flag &&
  
      avctx->internal->allocate_progress = 1;
  
 +    flush_change(h);
 +
      return 0;
  }
  
@@@ -1702,10 -1637,6 +1703,10 @@@ static int decode_init_thread_copy(AVCo
      memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
      memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
  
 +    h->rbsp_buffer[0] = NULL;
 +    h->rbsp_buffer[1] = NULL;
 +    h->rbsp_buffer_size[0] = 0;
 +    h->rbsp_buffer_size[1] = 0;
      h->context_initialized = 0;
  
      return 0;
@@@ -1727,7 -1658,7 +1728,7 @@@ static int decode_update_thread_context
      int context_reinitialized = 0;
      int i, ret;
  
 -    if (dst == src || !h1->context_initialized)
 +    if (dst == src)
          return 0;
  
      if (inited &&
          h->mb_num    = h1->mb_num;
          h->mb_stride = h1->mb_stride;
          h->b_stride  = h1->b_stride;
 +        // SPS/PPS
 +        if ((ret = copy_parameter_set((void **)h->sps_buffers,
 +                                      (void **)h1->sps_buffers,
 +                                      MAX_SPS_COUNT, sizeof(SPS))) < 0)
 +            return ret;
 +        h->sps = h1->sps;
 +        if ((ret = copy_parameter_set((void **)h->pps_buffers,
 +                                      (void **)h1->pps_buffers,
 +                                      MAX_PPS_COUNT, sizeof(PPS))) < 0)
 +            return ret;
 +        h->pps = h1->pps;
  
          if ((err = h264_slice_header_init(h, 1)) < 0) {
              av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
          }
          context_reinitialized = 1;
  
 -        /* update linesize on resize. The decoder doesn't
 -         * necessarily call h264_frame_start in the new thread */
 -        h->linesize   = h1->linesize;
 -        h->uvlinesize = h1->uvlinesize;
 -
 -        /* copy block_offset since frame_start may not be called */
 -        memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
 +#if 0
 +        h264_set_parameter_from_sps(h);
 +        //Note we set context_reinitialized which will cause h264_set_parameter_from_sps to be reexecuted
 +        h->cur_chroma_format_idc = h1->cur_chroma_format_idc;
 +#endif
      }
 +    /* update linesize on resize for h264. The h264 decoder doesn't
 +     * necessarily call ff_MPV_frame_start in the new thread */
 +    h->linesize   = h1->linesize;
 +    h->uvlinesize = h1->uvlinesize;
 +
 +    /* copy block_offset since frame_start may not be called */
 +    memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
  
      if (!inited) {
          for (i = 0; i < MAX_SPS_COUNT; i++)
          for (i = 0; i < MAX_PPS_COUNT; i++)
              av_freep(h->pps_buffers + i);
  
 -        memcpy(h, h1, sizeof(*h1));
 +        av_freep(&h->rbsp_buffer[0]);
 +        av_freep(&h->rbsp_buffer[1]);
 +        memcpy(h, h1, offsetof(H264Context, intra_pcm_ptr));
 +        memcpy(&h->cabac, &h1->cabac,
 +               sizeof(H264Context) - offsetof(H264Context, cabac));
 +        av_assert0((void*)&h->cabac == &h->mb_padding + 1);
 +
          memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
          memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
 +
          memset(&h->er, 0, sizeof(h->er));
          memset(&h->mb, 0, sizeof(h->mb));
          memset(&h->mb_luma_dc, 0, sizeof(h->mb_luma_dc));
          memset(&h->mb_padding, 0, sizeof(h->mb_padding));
 -        h->context_initialized = 0;
 -
 -        memset(&h->cur_pic, 0, sizeof(h->cur_pic));
 -        av_frame_unref(&h->cur_pic.f);
 -        h->cur_pic.tf.f = &h->cur_pic.f;
  
          h->avctx             = dst;
          h->DPB               = NULL;
          h->mb_type_pool      = NULL;
          h->ref_index_pool    = NULL;
          h->motion_val_pool   = NULL;
 +        for (i = 0; i < 2; i++) {
 +            h->rbsp_buffer[i] = NULL;
 +            h->rbsp_buffer_size[i] = 0;
 +        }
 +
 +        if (h1->context_initialized) {
 +        h->context_initialized = 0;
 +
 +        memset(&h->cur_pic, 0, sizeof(h->cur_pic));
 +        av_frame_unref(&h->cur_pic.f);
 +        h->cur_pic.tf.f = &h->cur_pic.f;
  
          ret = ff_h264_alloc_tables(h);
          if (ret < 0) {
              av_log(dst, AV_LOG_ERROR, "context_init() failed.\n");
              return ret;
          }
 -
 -        for (i = 0; i < 2; i++) {
 -            h->rbsp_buffer[i]      = NULL;
 -            h->rbsp_buffer_size[i] = 0;
          }
 +
          h->bipred_scratchpad = NULL;
          h->edge_emu_buffer   = NULL;
  
          h->thread_context[0] = h;
 -
 -        h->context_initialized = 1;
 +        h->context_initialized = h1->context_initialized;
      }
  
      h->avctx->coded_height  = h1->avctx->coded_height;
      h->droppable            = h1->droppable;
      h->low_delay            = h1->low_delay;
  
 -    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
 +    for (i = 0; h->DPB && i < H264_MAX_PICTURE_COUNT; i++) {
          unref_picture(h, &h->DPB[i]);
 -        if (h1->DPB[i].f.buf[0] &&
 +        if (h1->DPB && h1->DPB[i].f.buf[0] &&
              (ret = ref_picture(h, &h->DPB[i], &h1->DPB[i])) < 0)
              return ret;
      }
  
      h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
      unref_picture(h, &h->cur_pic);
 -    if ((ret = ref_picture(h, &h->cur_pic, &h1->cur_pic)) < 0)
 +    if (h1->cur_pic.f.buf[0] && (ret = ref_picture(h, &h->cur_pic, &h1->cur_pic)) < 0)
          return ret;
  
      h->workaround_bugs = h1->workaround_bugs;
      h->low_delay       = h1->low_delay;
      h->droppable       = h1->droppable;
  
 -    /* frame_start may not be called for the next thread (if it's decoding
 -     * a bottom field) so this has to be allocated here */
 -    err = alloc_scratch_buffers(h, h1->linesize);
 -    if (err < 0)
 -        return err;
 -
      // extradata/NAL handling
      h->is_avc = h1->is_avc;
  
      copy_picture_range(h->delayed_pic, h1->delayed_pic,
                         MAX_DELAYED_PIC_COUNT + 2, h, h1);
  
 -    h->last_slice_type = h1->last_slice_type;
 +    h->frame_recovered       = h1->frame_recovered;
  
      if (context_reinitialized)
          h264_set_parameter_from_sps(h);
      h->outputed_poc          = h->next_outputed_poc;
  
      h->recovery_frame        = h1->recovery_frame;
 -    h->frame_recovered       = h1->frame_recovered;
  
      return err;
  }
@@@ -1938,17 -1851,6 +1939,17 @@@ static int h264_frame_start(H264Contex
      H264Picture *pic;
      int i, ret;
      const int pixel_shift = h->pixel_shift;
 +    int c[4] = {
 +        1<<(h->sps.bit_depth_luma-1),
 +        1<<(h->sps.bit_depth_chroma-1),
 +        1<<(h->sps.bit_depth_chroma-1),
 +        -1
 +    };
 +
 +    if (!ff_thread_can_start_frame(h->avctx)) {
 +        av_log(h->avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
 +        return -1;
 +    }
  
      release_unused_pictures(h, 1);
      h->cur_pic_ptr = NULL;
      pic->reference              = h->droppable ? 0 : h->picture_structure;
      pic->f.coded_picture_number = h->coded_picture_number++;
      pic->field_picture          = h->picture_structure != PICT_FRAME;
 +
      /*
       * Zero key_frame here; IDR markings per slice in frame or fields are ORed
       * in later.
      pic->f.key_frame = 0;
      pic->mmco_reset  = 0;
      pic->recovered   = 0;
 +    pic->invalid_gap = 0;
  
      if ((ret = alloc_picture(h, pic)) < 0)
          return ret;
 +    if(!h->frame_recovered && !h->avctx->hwaccel &&
 +       !(h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU))
 +        avpriv_color_frame(&pic->f, c);
  
      h->cur_pic_ptr = pic;
      unref_picture(h, &h->cur_pic);
 +    if (CONFIG_ERROR_RESILIENCE) {
 +        memset(&h->er.cur_pic, 0, sizeof(h->er.cur_pic));
 +    }
 +
      if ((ret = ref_picture(h, &h->cur_pic, h->cur_pic_ptr)) < 0)
          return ret;
  
 -    if (CONFIG_ERROR_RESILIENCE)
 +    if (CONFIG_ERROR_RESILIENCE) {
          ff_er_frame_start(&h->er);
 +        memset(&h->er.last_pic, 0, sizeof(h->er.last_pic));
 +        memset(&h->er.next_pic, 0, sizeof(h->er.next_pic));
 +    }
  
      assert(h->linesize && h->uvlinesize);
  
          h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
      }
  
 -    /* can't be in alloc_tables because linesize isn't known there.
 -     * FIXME: redo bipred weight to not require extra buffer? */
 -    for (i = 0; i < h->slice_context_count; i++)
 -        if (h->thread_context[i]) {
 -            ret = alloc_scratch_buffers(h->thread_context[i], h->linesize);
 -            if (ret < 0)
 -                return ret;
 -        }
 -
 -    /* Some macroblocks can be accessed before they're available in case
 -     * of lost slices, MBAFF or threading. */
 -    memset(h->slice_table, -1,
 -           (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
 -
 -    // s->decode = (s->flags & CODEC_FLAG_PSNR) || !s->encoding ||
 -    //             s->current_picture.f.reference /* || h->contains_intra */ || 1;
 +    // s->decode = (h->flags & CODEC_FLAG_PSNR) || !s->encoding ||
 +    //             h->cur_pic.reference /* || h->contains_intra */ || 1;
  
      /* We mark the current picture as non-reference after allocating it, so
       * that if we break out due to an error it can be released automatically
@@@ -2039,6 -1943,7 +2040,6 @@@ static void decode_postinit(H264Contex
      H264Picture *out = h->cur_pic_ptr;
      H264Picture *cur = h->cur_pic_ptr;
      int i, pics, out_of_order, out_idx;
 -    int invalid = 0, cnt = 0;
  
      h->cur_pic_ptr->f.pict_type = h->pict_type;
  
              stereo->flags = AV_STEREO3D_FLAG_INVERT;
      }
  
 +    cur->mmco_reset = h->mmco_reset;
 +    h->mmco_reset = 0;
 +
      // FIXME do something with unavailable reference frames
  
      /* Sort B-frames into display order */
          h->low_delay           = 0;
      }
  
 +    for (i = 0; 1; i++) {
 +        if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
 +            if(i)
 +                h->last_pocs[i-1] = cur->poc;
 +            break;
 +        } else if(i) {
 +            h->last_pocs[i-1]= h->last_pocs[i];
 +        }
 +    }
 +    out_of_order = MAX_DELAYED_PIC_COUNT - i;
 +    if(   cur->f.pict_type == AV_PICTURE_TYPE_B
 +       || (h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > INT_MIN && h->last_pocs[MAX_DELAYED_PIC_COUNT-1] - h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > 2))
 +        out_of_order = FFMAX(out_of_order, 1);
 +    if (out_of_order == MAX_DELAYED_PIC_COUNT) {
 +        av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
 +        for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
 +            h->last_pocs[i] = INT_MIN;
 +        h->last_pocs[0] = cur->poc;
 +        cur->mmco_reset = 1;
 +    } else if(h->avctx->has_b_frames < out_of_order && !h->sps.bitstream_restriction_flag){
 +        av_log(h->avctx, AV_LOG_VERBOSE, "Increasing reorder buffer to %d\n", out_of_order);
 +        h->avctx->has_b_frames = out_of_order;
 +        h->low_delay = 0;
 +    }
 +
      pics = 0;
      while (h->delayed_pic[pics])
          pics++;
  
 -    assert(pics <= MAX_DELAYED_PIC_COUNT);
 +    av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
  
      h->delayed_pic[pics++] = cur;
      if (cur->reference == 0)
          cur->reference = DELAYED_PIC_REF;
  
 -    /* Frame reordering. This code takes pictures from coding order and sorts
 -     * them by their incremental POC value into display order. It supports POC
 -     * gaps, MMCO reset codes and random resets.
 -     * A "display group" can start either with a IDR frame (f.key_frame = 1),
 -     * and/or can be closed down with a MMCO reset code. In sequences where
 -     * there is no delay, we can't detect that (since the frame was already
 -     * output to the user), so we also set h->mmco_reset to detect the MMCO
 -     * reset code.
 -     * FIXME: if we detect insufficient delays (as per h->avctx->has_b_frames),
 -     * we increase the delay between input and output. All frames affected by
 -     * the lag (e.g. those that should have been output before another frame
 -     * that we already returned to the user) will be dropped. This is a bug
 -     * that we will fix later. */
 -    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
 -        cnt     += out->poc < h->last_pocs[i];
 -        invalid += out->poc == INT_MIN;
 -    }
 -    if (!h->mmco_reset && !cur->f.key_frame &&
 -        cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
 -        h->mmco_reset = 2;
 -        if (pics > 1)
 -            h->delayed_pic[pics - 2]->mmco_reset = 2;
 -    }
 -    if (h->mmco_reset || cur->f.key_frame) {
 -        for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
 -            h->last_pocs[i] = INT_MIN;
 -        cnt     = 0;
 -        invalid = MAX_DELAYED_PIC_COUNT;
 -    }
      out     = h->delayed_pic[0];
      out_idx = 0;
 -    for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
 -                h->delayed_pic[i] &&
 -                !h->delayed_pic[i - 1]->mmco_reset &&
 -                !h->delayed_pic[i]->f.key_frame;
 +    for (i = 1; h->delayed_pic[i] &&
 +                !h->delayed_pic[i]->f.key_frame &&
 +                !h->delayed_pic[i]->mmco_reset;
           i++)
          if (h->delayed_pic[i]->poc < out->poc) {
              out     = h->delayed_pic[i];
              out_idx = i;
          }
      if (h->avctx->has_b_frames == 0 &&
 -        (h->delayed_pic[0]->f.key_frame || h->mmco_reset))
 +        (h->delayed_pic[0]->f.key_frame || h->delayed_pic[0]->mmco_reset))
          h->next_outputed_poc = INT_MIN;
 -    out_of_order = !out->f.key_frame && !h->mmco_reset &&
 -                   (out->poc < h->next_outputed_poc);
 +    out_of_order = out->poc < h->next_outputed_poc;
  
 -    if (h->sps.bitstream_restriction_flag &&
 -        h->avctx->has_b_frames >= h->sps.num_reorder_frames) {
 -    } else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
 -               h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
 -        if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
 -            h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
 -        }
 -        h->low_delay = 0;
 -    } else if (h->low_delay &&
 -               ((h->next_outputed_poc != INT_MIN &&
 -                 out->poc > h->next_outputed_poc + 2) ||
 -                cur->f.pict_type == AV_PICTURE_TYPE_B)) {
 -        h->low_delay = 0;
 -        h->avctx->has_b_frames++;
 -    }
 -
 -    if (pics > h->avctx->has_b_frames) {
 +    if (out_of_order || pics > h->avctx->has_b_frames) {
          out->reference &= ~DELAYED_PIC_REF;
          // for frame threading, the owner must be the second field's thread or
          // else the first thread can release the picture and reuse it unsafely
          for (i = out_idx; h->delayed_pic[i]; i++)
              h->delayed_pic[i] = h->delayed_pic[i + 1];
      }
 -    memmove(h->last_pocs, &h->last_pocs[1],
 -            sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
 -    h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
      if (!out_of_order && pics > h->avctx->has_b_frames) {
          h->next_output_pic = out;
 -        if (out->mmco_reset) {
 -            if (out_idx > 0) {
 -                h->next_outputed_poc                    = out->poc;
 -                h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
 -            } else {
 -                h->next_outputed_poc = INT_MIN;
 -            }
 -        } else {
 -            if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f.key_frame) {
 -                h->next_outputed_poc = INT_MIN;
 -            } else {
 -                h->next_outputed_poc = out->poc;
 -            }
 -        }
 -        h->mmco_reset = 0;
 +        if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f.key_frame || h->delayed_pic[0]->mmco_reset)) {
 +            h->next_outputed_poc = INT_MIN;
 +        } else
 +            h->next_outputed_poc = out->poc;
      } else {
 -        av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
 +        av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
      }
  
      if (h->next_output_pic) {
@@@ -2415,8 -2353,10 +2416,8 @@@ static av_always_inline void xchg_mb_bo
              XCHG(h->top_borders[top_idx][h->mb_x + 1],
                   src_y + (17 << pixel_shift), 1);
          }
 -    }
 -    if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 -        if (chroma444) {
 -            if (deblock_top) {
 +        if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 +            if (chroma444) {
                  if (deblock_topleft) {
                      XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);
                      XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);
                      XCHG(h->top_borders[top_idx][h->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
                      XCHG(h->top_borders[top_idx][h->mb_x + 1] + (32 << pixel_shift), src_cr + (17 << pixel_shift), 1);
                  }
 -            }
 -        } else {
 -            if (deblock_top) {
 +            } else {
                  if (deblock_topleft) {
                      XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
                      XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
@@@ -2519,7 -2461,7 +2520,7 @@@ static av_always_inline void hl_decode_
                      uint64_t tr_high;
                      if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
                          const int topright_avail = (h->topright_samples_available << i) & 0x8000;
 -                        assert(h->mb_y || linesize <= block_offset[i]);
 +                        av_assert2(h->mb_y || linesize <= block_offset[i]);
                          if (!topright_avail) {
                              if (pixel_shift) {
                                  tr_high  = ((uint16_t *)ptr)[3 - linesize / 2] * 0x0001000100010001ULL;
@@@ -2810,33 -2752,24 +2811,33 @@@ static void implicit_weight_table(H264C
   */
  static void idr(H264Context *h)
  {
 +    int i;
      ff_h264_remove_all_refs(h);
      h->prev_frame_num        = 0;
      h->prev_frame_num_offset = 0;
 -    h->prev_poc_msb          =
 +    h->prev_poc_msb          = 1<<16;
      h->prev_poc_lsb          = 0;
 +    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
 +        h->last_pocs[i] = INT_MIN;
  }
  
  /* forget old pics after a seek */
  static void flush_change(H264Context *h)
  {
 -    int i;
 -    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
 -        h->last_pocs[i] = INT_MIN;
 +    int i, j;
 +
      h->outputed_poc          = h->next_outputed_poc = INT_MIN;
      h->prev_interlaced_frame = 1;
      idr(h);
 -    if (h->cur_pic_ptr)
 +
 +    h->prev_frame_num = -1;
 +    if (h->cur_pic_ptr) {
          h->cur_pic_ptr->reference = 0;
 +        for (j=i=0; h->delayed_pic[i]; i++)
 +            if (h->delayed_pic[i] != h->cur_pic_ptr)
 +                h->delayed_pic[j++] = h->delayed_pic[i];
 +        h->delayed_pic[j] = NULL;
 +    }
      h->first_field = 0;
      memset(h->ref_list[0], 0, sizeof(h->ref_list[0]));
      memset(h->ref_list[1], 0, sizeof(h->ref_list[1]));
      ff_h264_reset_sei(h);
      h->recovery_frame = -1;
      h->frame_recovered = 0;
 +    h->list_count = 0;
 +    h->current_slice = 0;
 +    h->mmco_reset = 1;
  }
  
  /* forget old pics after a seek */
@@@ -2856,7 -2786,7 +2857,7 @@@ static void flush_dpb(AVCodecContext *a
      H264Context *h = avctx->priv_data;
      int i;
  
 -    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
 +    for (i = 0; i <= MAX_DELAYED_PIC_COUNT; i++) {
          if (h->delayed_pic[i])
              h->delayed_pic[i]->reference = 0;
          h->delayed_pic[i] = NULL;
@@@ -2982,19 -2912,19 +2983,19 @@@ static void init_scan_tables(H264Contex
  #undef TRANSPOSE
      }
      if (h->sps.transform_bypass) { // FIXME same ugly
 -        h->zigzag_scan_q0          = zigzag_scan;
 -        h->zigzag_scan8x8_q0       = ff_zigzag_direct;
 -        h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
 -        h->field_scan_q0           = field_scan;
 -        h->field_scan8x8_q0        = field_scan8x8;
 -        h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
 +        memcpy(h->zigzag_scan_q0          , zigzag_scan             , sizeof(h->zigzag_scan_q0         ));
 +        memcpy(h->zigzag_scan8x8_q0       , ff_zigzag_direct        , sizeof(h->zigzag_scan8x8_q0      ));
 +        memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc    , sizeof(h->zigzag_scan8x8_cavlc_q0));
 +        memcpy(h->field_scan_q0           , field_scan              , sizeof(h->field_scan_q0          ));
 +        memcpy(h->field_scan8x8_q0        , field_scan8x8           , sizeof(h->field_scan8x8_q0       ));
 +        memcpy(h->field_scan8x8_cavlc_q0  , field_scan8x8_cavlc     , sizeof(h->field_scan8x8_cavlc_q0 ));
      } else {
 -        h->zigzag_scan_q0          = h->zigzag_scan;
 -        h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
 -        h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
 -        h->field_scan_q0           = h->field_scan;
 -        h->field_scan8x8_q0        = h->field_scan8x8;
 -        h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
 +        memcpy(h->zigzag_scan_q0          , h->zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
 +        memcpy(h->zigzag_scan8x8_q0       , h->zigzag_scan8x8       , sizeof(h->zigzag_scan8x8_q0      ));
 +        memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
 +        memcpy(h->field_scan_q0           , h->field_scan           , sizeof(h->field_scan_q0          ));
 +        memcpy(h->field_scan8x8_q0        , h->field_scan8x8        , sizeof(h->field_scan8x8_q0       ));
 +        memcpy(h->field_scan8x8_cavlc_q0  , h->field_scan8x8_cavlc  , sizeof(h->field_scan8x8_cavlc_q0 ));
      }
  }
  
@@@ -3003,8 -2933,6 +3004,8 @@@ static void h264_set_erpic(ERPicture *d
  {
      int i;
  
 +    memset(dst, 0, sizeof(*dst));
 +
      if (!src)
          return;
  
@@@ -3027,9 -2955,9 +3028,9 @@@ static int field_end(H264Context *h, in
      int err = 0;
      h->mb_y = 0;
  
 -    if (!in_setup && !h->droppable)
 -        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
 -                                  h->picture_structure == PICT_BOTTOM_FIELD);
 +    if (CONFIG_H264_VDPAU_DECODER &&
 +        h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
 +        ff_vdpau_h264_set_reference_frames(h);
  
      if (in_setup || !(avctx->active_thread_type & FF_THREAD_FRAME)) {
          if (!h->droppable) {
                     "hardware accelerator failed to decode picture\n");
      }
  
 +    if (CONFIG_H264_VDPAU_DECODER &&
 +        h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
 +        ff_vdpau_h264_picture_complete(h);
 +
      /*
       * FIXME: Error handling code does not seem to support interlaced
       * when slices span multiple rows
       * past end by one (callers fault) and resync_mb_y != 0
       * causes problems for the first MB line, too.
       */
 -    if (CONFIG_ERROR_RESILIENCE && !FIELD_PICTURE(h)) {
 +    if (CONFIG_ERROR_RESILIENCE && !FIELD_PICTURE(h) && h->current_slice && !h->sps.new) {
          h264_set_erpic(&h->er.cur_pic, h->cur_pic_ptr);
 -        h264_set_erpic(&h->er.last_pic,
 -                       h->ref_count[0] ? &h->ref_list[0][0] : NULL);
 -        h264_set_erpic(&h->er.next_pic,
 -                       h->ref_count[1] ? &h->ref_list[1][0] : NULL);
          ff_er_frame_end(&h->er);
      }
 +    if (!in_setup && !h->droppable)
 +        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
 +                                  h->picture_structure == PICT_BOTTOM_FIELD);
      emms_c();
  
      h->current_slice = 0;
@@@ -3150,15 -3075,7 +3151,15 @@@ static int h264_set_parameter_from_sps(
  
      if (h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
          h->cur_chroma_format_idc      != h->sps.chroma_format_idc) {
 -        if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
 +        if (h->avctx->codec &&
 +            h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU &&
 +            (h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {
 +            av_log(h->avctx, AV_LOG_ERROR,
 +                   "VDPAU decoding does not support video colorspace.\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 14 &&
 +            h->sps.bit_depth_luma != 11 && h->sps.bit_depth_luma != 13) {
              h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
              h->cur_chroma_format_idc      = h->sps.chroma_format_idc;
              h->pixel_shift                = h->sps.bit_depth_luma > 8;
              ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
              ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
                                h->sps.chroma_format_idc);
 +
              if (CONFIG_ERROR_RESILIENCE)
                  ff_dsputil_init(&h->dsp, h->avctx);
              ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
      return 0;
  }
  
 -static enum AVPixelFormat get_pixel_format(H264Context *h)
 +static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
  {
      switch (h->sps.bit_depth_luma) {
      case 9:
          else
              return AV_PIX_FMT_YUV420P10;
          break;
 -    case 8:
 +    case 12:
 +        if (CHROMA444(h)) {
 +            if (h->avctx->colorspace == AVCOL_SPC_RGB) {
 +                return AV_PIX_FMT_GBRP12;
 +            } else
 +                return AV_PIX_FMT_YUV444P12;
 +        } else if (CHROMA422(h))
 +            return AV_PIX_FMT_YUV422P12;
 +        else
 +            return AV_PIX_FMT_YUV420P12;
 +        break;
 +    case 14:
          if (CHROMA444(h)) {
              if (h->avctx->colorspace == AVCOL_SPC_RGB) {
 -                return AV_PIX_FMT_GBRP;
 +                return AV_PIX_FMT_GBRP14;
              } else
 -                return h->avctx->color_range == AVCOL_RANGE_JPEG ? AV_PIX_FMT_YUVJ444P
 -                                                                 : AV_PIX_FMT_YUV444P;
 +                return AV_PIX_FMT_YUV444P14;
 +        } else if (CHROMA422(h))
 +            return AV_PIX_FMT_YUV422P14;
 +        else
 +            return AV_PIX_FMT_YUV420P14;
 +        break;
 +    case 8:
 +        if (CHROMA444(h)) {
 +            if (h->avctx->colorspace == AVCOL_SPC_RGB) {
 +                av_log(h->avctx, AV_LOG_DEBUG, "Detected GBR colorspace.\n");
 +                return AV_PIX_FMT_GBR24P;
 +            } else if (h->avctx->colorspace == AVCOL_SPC_YCGCO) {
 +                av_log(h->avctx, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
 +            }
 +            return h->avctx->color_range == AVCOL_RANGE_JPEG ? AV_PIX_FMT_YUVJ444P
 +                                                                : AV_PIX_FMT_YUV444P;
          } else if (CHROMA422(h)) {
              return h->avctx->color_range == AVCOL_RANGE_JPEG ? AV_PIX_FMT_YUVJ422P
                                                               : AV_PIX_FMT_YUV422P;
          } else {
 -            return h->avctx->get_format(h->avctx, h->avctx->codec->pix_fmts ?
 +            int i;
 +            const enum AVPixelFormat * fmt = h->avctx->codec->pix_fmts ?
                                          h->avctx->codec->pix_fmts :
                                          h->avctx->color_range == AVCOL_RANGE_JPEG ?
                                          h264_hwaccel_pixfmt_list_jpeg_420 :
 -                                        h264_hwaccel_pixfmt_list_420);
 +                                        h264_hwaccel_pixfmt_list_420;
 +
 +            for (i=0; fmt[i] != AV_PIX_FMT_NONE; i++)
 +                if (fmt[i] == h->avctx->pix_fmt && !force_callback)
 +                    return fmt[i];
 +            return ff_thread_get_format(h->avctx, fmt);
          }
          break;
      default:
@@@ -3268,8 -3153,6 +3269,8 @@@ static int init_dimensions(H264Context 
  {
      int width  = h->width  - (h->sps.crop_right + h->sps.crop_left);
      int height = h->height - (h->sps.crop_top   + h->sps.crop_bottom);
 +    av_assert0(h->sps.crop_right + h->sps.crop_left < (unsigned)h->width);
 +    av_assert0(h->sps.crop_top + h->sps.crop_bottom < (unsigned)h->height);
  
      /* handle container cropping */
      if (!h->sps.crop &&
@@@ -3360,9 -3243,7 +3361,9 @@@ static int h264_slice_header_init(H264C
              if (!c)
                  return AVERROR(ENOMEM);
              c->avctx             = h->avctx;
 -            c->dsp               = h->dsp;
 +            if (CONFIG_ERROR_RESILIENCE) {
 +                c->dsp               = h->dsp;
 +            }
              c->vdsp              = h->vdsp;
              c->h264dsp           = h->h264dsp;
              c->h264qpel          = h->h264qpel;
              c->sps               = h->sps;
              c->pps               = h->pps;
              c->pixel_shift       = h->pixel_shift;
 +            c->cur_chroma_format_idc = h->cur_chroma_format_idc;
              c->width             = h->width;
              c->height            = h->height;
              c->linesize          = h->linesize;
  int ff_set_ref_count(H264Context *h)
  {
      int ref_count[2], list_count;
 -    int num_ref_idx_active_override_flag, max_refs;
 +    int num_ref_idx_active_override_flag;
  
      // set defaults, might be overridden a few lines later
      ref_count[0] = h->pps.ref_count[0];
      ref_count[1] = h->pps.ref_count[1];
  
      if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
 +        unsigned max[2];
 +        max[0] = max[1] = h->picture_structure == PICT_FRAME ? 15 : 31;
 +
          if (h->slice_type_nos == AV_PICTURE_TYPE_B)
              h->direct_spatial_mv_pred = get_bits1(&h->gb);
          num_ref_idx_active_override_flag = get_bits1(&h->gb);
  
          if (num_ref_idx_active_override_flag) {
              ref_count[0] = get_ue_golomb(&h->gb) + 1;
 -            if (ref_count[0] < 1)
 -                return AVERROR_INVALIDDATA;
              if (h->slice_type_nos == AV_PICTURE_TYPE_B) {
                  ref_count[1] = get_ue_golomb(&h->gb) + 1;
 -                if (ref_count[1] < 1)
 -                    return AVERROR_INVALIDDATA;
 -            }
 +            } else
 +                // full range is spec-ok in this case, even for frames
 +                ref_count[1] = 1;
 +        }
 +
 +        if (ref_count[0]-1 > max[0] || ref_count[1]-1 > max[1]){
 +            av_log(h->avctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n", ref_count[0]-1, max[0], ref_count[1]-1, max[1]);
 +            h->ref_count[0] = h->ref_count[1] = 0;
 +            h->list_count   = 0;
 +            return AVERROR_INVALIDDATA;
          }
  
          if (h->slice_type_nos == AV_PICTURE_TYPE_B)
          ref_count[0] = ref_count[1] = 0;
      }
  
 -    max_refs = h->picture_structure == PICT_FRAME ? 16 : 32;
 -
 -    if (ref_count[0] > max_refs || ref_count[1] > max_refs) {
 -        av_log(h->avctx, AV_LOG_ERROR, "reference overflow\n");
 -        h->ref_count[0] = h->ref_count[1] = 0;
 -        return AVERROR_INVALIDDATA;
 -    }
 -
      if (list_count != h->list_count ||
          ref_count[0] != h->ref_count[0] ||
          ref_count[1] != h->ref_count[1]) {
      return 0;
  }
  
 +static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
 +{
 +    switch (a) {
 +    case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
 +    case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
 +    case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
 +    default:
 +        return a;
 +    }
 +}
 +
  /**
   * Decode a slice header.
   * This will (re)intialize the decoder and call h264_frame_start() as needed.
@@@ -3487,15 -3356,15 +3488,15 @@@ static int decode_slice_header(H264Cont
      unsigned int pps_id;
      int ret;
      unsigned int slice_type, tmp, i, j;
 -    int default_ref_list_done = 0;
      int last_pic_structure, last_pic_droppable;
 +    int must_reinit;
      int needs_reinit = 0;
      int field_pic_flag, bottom_field_flag;
  
      h->qpel_put = h->h264qpel.put_h264_qpel_pixels_tab;
      h->qpel_avg = h->h264qpel.avg_h264_qpel_pixels_tab;
  
 -    first_mb_in_slice = get_ue_golomb(&h->gb);
 +    first_mb_in_slice = get_ue_golomb_long(&h->gb);
  
      if (first_mb_in_slice == 0) { // FIXME better field boundary detection
          if (h0->current_slice && h->cur_pic_ptr && FIELD_PICTURE(h)) {
          h->slice_type_fixed = 0;
  
      slice_type = golomb_to_pict_type[slice_type];
 -    if (slice_type == AV_PICTURE_TYPE_I ||
 -        (h0->current_slice != 0 && slice_type == h0->last_slice_type)) {
 -        default_ref_list_done = 1;
 -    }
      h->slice_type     = slice_type;
      h->slice_type_nos = slice_type & 3;
  
                 pps_id);
          return AVERROR_INVALIDDATA;
      }
 +    if (h0->au_pps_id >= 0 && pps_id != h0->au_pps_id) {
 +        av_log(h->avctx, AV_LOG_ERROR,
 +               "PPS change from %d to %d forbidden\n",
 +               h0->au_pps_id, pps_id);
 +        return AVERROR_INVALIDDATA;
 +    }
      h->pps = *h0->pps_buffers[pps_id];
  
      if (!h0->sps_buffers[h->pps.sps_id]) {
      }
  
      if (h->pps.sps_id != h->sps.sps_id ||
 +        h->pps.sps_id != h->current_sps_id ||
          h0->sps_buffers[h->pps.sps_id]->new) {
 -        h0->sps_buffers[h->pps.sps_id]->new = 0;
  
          h->sps = *h0->sps_buffers[h->pps.sps_id];
  
 +        if (h->mb_width  != h->sps.mb_width ||
 +            h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) ||
 +            h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
 +            h->cur_chroma_format_idc != h->sps.chroma_format_idc
 +        )
 +            needs_reinit = 1;
 +
          if (h->bit_depth_luma    != h->sps.bit_depth_luma ||
              h->chroma_format_idc != h->sps.chroma_format_idc) {
              h->bit_depth_luma    = h->sps.bit_depth_luma;
      h->avctx->level   = h->sps.level_idc;
      h->avctx->refs    = h->sps.ref_frame_count;
  
 -    if (h->mb_width  != h->sps.mb_width ||
 -        h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag))
 -        needs_reinit = 1;
 +    must_reinit = (h->context_initialized &&
 +                    (   16*h->sps.mb_width != h->avctx->coded_width
 +                     || 16*h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) != h->avctx->coded_height
 +                     || h->avctx->bits_per_raw_sample != h->sps.bit_depth_luma
 +                     || h->cur_chroma_format_idc != h->sps.chroma_format_idc
 +                     || av_cmp_q(h->sps.sar, h->avctx->sample_aspect_ratio)
 +                     || h->mb_width  != h->sps.mb_width
 +                     || h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag)
 +                    ));
 +    if (non_j_pixfmt(h0->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h0, 0)))
 +        must_reinit = 1;
  
      h->mb_width  = h->sps.mb_width;
      h->mb_height = h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
          return ret;
  
      if (h->sps.video_signal_type_present_flag) {
 -        h->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG
 -                                                  : AVCOL_RANGE_MPEG;
 +        h->avctx->color_range = h->sps.full_range>0 ? AVCOL_RANGE_JPEG
 +                                                    : AVCOL_RANGE_MPEG;
          if (h->sps.colour_description_present_flag) {
              if (h->avctx->colorspace != h->sps.colorspace)
                  needs_reinit = 1;
      if (h->context_initialized &&
          (h->width  != h->avctx->coded_width   ||
           h->height != h->avctx->coded_height  ||
 +         must_reinit ||
           needs_reinit)) {
          if (h != h0) {
              av_log(h->avctx, AV_LOG_ERROR,
  
          flush_change(h);
  
 -        if ((ret = get_pixel_format(h)) < 0)
 +        if ((ret = get_pixel_format(h, 1)) < 0)
              return ret;
          h->avctx->pix_fmt = ret;
  
          av_log(h->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "
 -               "pix_fmt: %d\n", h->width, h->height, h->avctx->pix_fmt);
 +               "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
  
          if ((ret = h264_slice_header_init(h, 1)) < 0) {
              av_log(h->avctx, AV_LOG_ERROR,
              return AVERROR_PATCHWELCOME;
          }
  
 -        if ((ret = get_pixel_format(h)) < 0)
 +        if ((ret = get_pixel_format(h, 1)) < 0)
              return ret;
          h->avctx->pix_fmt = ret;
  
      if (h->sps.frame_mbs_only_flag) {
          h->picture_structure = PICT_FRAME;
      } else {
 +        if (!h->sps.direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
 +            av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
 +            return -1;
 +        }
          field_pic_flag = get_bits1(&h->gb);
          if (field_pic_flag) {
              bottom_field_flag = get_bits1(&h->gb);
           * Here, we're using that to see if we should mark previously
           * decode frames as "finished".
           * We have to do that before the "dummy" in-between frame allocation,
 -         * since that can modify s->current_picture_ptr. */
 +         * since that can modify h->cur_pic_ptr. */
          if (h0->first_field) {
              assert(h0->cur_pic_ptr);
              assert(h0->cur_pic_ptr->f.buf[0]);
              assert(h0->cur_pic_ptr->reference != DELAYED_PIC_REF);
  
 +            /* Mark old field/frame as completed */
 +            if (h0->cur_pic_ptr->tf.owner == h0->avctx) {
 +                ff_thread_report_progress(&h0->cur_pic_ptr->tf, INT_MAX,
 +                                          last_pic_structure == PICT_BOTTOM_FIELD);
 +            }
 +
              /* figure out if we have a complementary field pair */
              if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
                  /* Previous field is unmatched. Don't display it, but let it
                   * remain for reference if marked as such. */
 -                if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {
 +                if (last_pic_structure != PICT_FRAME) {
                      ff_thread_report_progress(&h0->cur_pic_ptr->tf, INT_MAX,
                                                last_pic_structure == PICT_TOP_FIELD);
                  }
                       * different frame_nums. Consider this field first in
                       * pair. Throw away previous field except for reference
                       * purposes. */
 -                    if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {
 +                    if (last_pic_structure != PICT_FRAME) {
                          ff_thread_report_progress(&h0->cur_pic_ptr->tf, INT_MAX,
                                                    last_pic_structure == PICT_TOP_FIELD);
                      }
              }
          }
  
 -        while (h->frame_num != h->prev_frame_num &&
 +        while (h->frame_num != h->prev_frame_num && !h0->first_field &&
                 h->frame_num != (h->prev_frame_num + 1) % (1 << h->sps.log2_max_frame_num)) {
              H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
              av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
                     h->frame_num, h->prev_frame_num);
 +            if (!h->sps.gaps_in_frame_num_allowed_flag)
 +                for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
 +                    h->last_pocs[i] = INT_MIN;
              ret = h264_frame_start(h);
              if (ret < 0) {
                  h0->first_field = 0;
              h->prev_frame_num++;
              h->prev_frame_num        %= 1 << h->sps.log2_max_frame_num;
              h->cur_pic_ptr->frame_num = h->prev_frame_num;
 +            h->cur_pic_ptr->invalid_gap = !h->sps.gaps_in_frame_num_allowed_flag;
              ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
              ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
              ret = ff_generate_sliding_window_mmcos(h, 1);
                  h0->first_field = FIELD_PICTURE(h);
              } else {
                  if (h0->cur_pic_ptr->frame_num != h->frame_num) {
 +                    ff_thread_report_progress(&h0->cur_pic_ptr->tf, INT_MAX,
 +                                              h0->picture_structure==PICT_BOTTOM_FIELD);
                      /* This and the previous field had different frame_nums.
                       * Consider this field first in pair. Throw away previous
                       * one except for reference purposes. */
          } else {
              release_unused_pictures(h, 0);
          }
 +        /* Some macroblocks can be accessed before they're available in case
 +        * of lost slices, MBAFF or threading. */
 +        if (FIELD_PICTURE(h)) {
 +            for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
 +                memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
 +        } else {
 +            memset(h->slice_table, -1,
 +                (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
 +        }
 +        h0->last_slice_type = -1;
      }
      if (h != h0 && (ret = clone_slice(h, h0)) < 0)
          return ret;
  
 +    /* can't be in alloc_tables because linesize isn't known there.
 +     * FIXME: redo bipred weight to not require extra buffer? */
 +    for (i = 0; i < h->slice_context_count; i++)
 +        if (h->thread_context[i]) {
 +            ret = alloc_scratch_buffers(h->thread_context[i], h->linesize);
 +            if (ret < 0)
 +                return ret;
 +        }
 +
      h->cur_pic_ptr->frame_num = h->frame_num; // FIXME frame_num cleanup
  
 -    assert(h->mb_num == h->mb_width * h->mb_height);
 +    av_assert1(h->mb_num == h->mb_width * h->mb_height);
      if (first_mb_in_slice << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
          first_mb_in_slice >= h->mb_num) {
          av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
                                 FIELD_OR_MBAFF_PICTURE(h);
      if (h->picture_structure == PICT_BOTTOM_FIELD)
          h->resync_mb_y = h->mb_y = h->mb_y + 1;
 -    assert(h->mb_y < h->mb_height);
 +    av_assert1(h->mb_y < h->mb_height);
  
      if (h->picture_structure == PICT_FRAME) {
          h->curr_pic_num = h->frame_num;
      ret = ff_set_ref_count(h);
      if (ret < 0)
          return ret;
 -    else if (ret == 1)
 -        default_ref_list_done = 0;
  
 -    if (!default_ref_list_done)
 +    if (slice_type != AV_PICTURE_TYPE_I &&
 +        (h0->current_slice == 0 ||
 +         slice_type != h0->last_slice_type ||
 +         memcmp(h0->last_ref_count, h0->ref_count, sizeof(h0->ref_count)))) {
 +
          ff_h264_fill_default_ref_list(h);
 +    }
  
      if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
         ret = ff_h264_decode_ref_pic_list_reordering(h);
                     6 * (h->sps.bit_depth_luma - 8);
  
      h0->last_slice_type = slice_type;
 +    memcpy(h0->last_ref_count, h0->ref_count, sizeof(h0->last_ref_count));
      h->slice_num        = ++h0->current_slice;
 -    if (h->slice_num >= MAX_SLICES) {
 -        av_log(h->avctx, AV_LOG_ERROR,
 -               "Too many slices, increase MAX_SLICES and recompile\n");
 +
 +    if (h->slice_num)
 +        h0->slice_row[(h->slice_num-1)&(MAX_SLICES-1)]= h->resync_mb_y;
 +    if (   h0->slice_row[h->slice_num&(MAX_SLICES-1)] + 3 >= h->resync_mb_y
 +        && h0->slice_row[h->slice_num&(MAX_SLICES-1)] <= h->resync_mb_y
 +        && h->slice_num >= MAX_SLICES) {
 +        //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
 +        av_log(h->avctx, AV_LOG_WARNING, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", h->slice_num, MAX_SLICES);
      }
  
      for (j = 0; j < 2; j++) {
                               (h->ref_list[j][i].reference & 3);
      }
  
 +    if (h->ref_count[0]) h264_set_erpic(&h->er.last_pic, &h->ref_list[0][0]);
 +    if (h->ref_count[1]) h264_set_erpic(&h->er.next_pic, &h->ref_list[1][0]);
 +
 +    h->er.ref_count = h->ref_count[0];
 +    h0->au_pps_id = pps_id;
 +    h->sps.new =
 +    h0->sps_buffers[h->pps.sps_id]->new = 0;
 +    h->current_sps_id = h->pps.sps_id;
 +
      if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
          av_log(h->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",
@@@ -4218,7 -4016,7 +4219,7 @@@ static av_always_inline void fill_filte
          if (USES_LIST(top_type, list)) {
              const int b_xy  = h->mb2b_xy[top_xy] + 3 * b_stride;
              const int b8_xy = 4 * top_xy + 2;
 -            int (*ref2frm)[64] = h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2);
 +            int (*ref2frm)[64] = (void*)(h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2));
              AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
              ref_cache[0 - 1 * 8] =
              ref_cache[1 - 1 * 8] = ref2frm[list][h->cur_pic.ref_index[list][b8_xy + 0]];
              if (USES_LIST(left_type[LTOP], list)) {
                  const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
                  const int b8_xy = 4 * left_xy[LTOP] + 1;
 -                int (*ref2frm)[64] = h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2);
 +                int (*ref2frm)[64] =(void*)( h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2));
                  AV_COPY32(mv_dst - 1 +  0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
                  AV_COPY32(mv_dst - 1 +  8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
                  AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
  
      {
          int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
 -        int (*ref2frm)[64] = h->ref2frm[h->slice_num & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2);
 +        int (*ref2frm)[64] = (void*)(h->ref2frm[h->slice_num & (MAX_SLICES - 1)][0] + (MB_MBAFF(h) ? 20 : 2));
          uint32_t ref01 = (pack16to32(ref2frm[list][ref[0]], ref2frm[list][ref[1]]) & 0x00FF00FF) * 0x0101;
          uint32_t ref23 = (pack16to32(ref2frm[list][ref[2]], ref2frm[list][ref[3]]) & 0x00FF00FF) * 0x0101;
          AV_WN32A(&ref_cache[0 * 8], ref01);
@@@ -4539,7 -4337,7 +4540,7 @@@ static void decode_finish_row(H264Conte
  
      ff_h264_draw_horiz_band(h, top, height);
  
 -    if (h->droppable)
 +    if (h->droppable || h->er.error_occurred)
          return;
  
      ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
  static void er_add_slice(H264Context *h, int startx, int starty,
                           int endx, int endy, int status)
  {
 -#if CONFIG_ERROR_RESILIENCE
 -    ERContext *er = &h->er;
 +    if (CONFIG_ERROR_RESILIENCE) {
 +        ERContext *er = &h->er;
  
 -    er->ref_count = h->ref_count[0];
 -    ff_er_add_slice(er, startx, starty, endx, endy, status);
 -#endif
 +        ff_er_add_slice(er, startx, starty, endx, endy, status);
 +    }
  }
  
  static int decode_slice(struct AVCodecContext *avctx, void *arg)
  
      h->mb_skip_run = -1;
  
 +    av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * h->linesize * ((scan8[15] - scan8[0]) >> 3));
 +
      h->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
                      avctx->codec_id != AV_CODEC_ID_H264 ||
                      (CONFIG_GRAY && (h->flags & CODEC_FLAG_GRAY));
  
 +    if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && h->er.error_status_table) {
 +        const int start_i  = av_clip(h->resync_mb_x + h->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
 +        if (start_i) {
 +            int prev_status = h->er.error_status_table[h->er.mb_index2xy[start_i - 1]];
 +            prev_status &= ~ VP_START;
 +            if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
 +                h->er.error_occurred = 1;
 +        }
 +    }
 +
      if (h->pps.cabac) {
          /* realign */
          align_get_bits(&h->gb);
                      loop_filter(h, lf_x_start, h->mb_x + 1);
                  return 0;
              }
 -            if (ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) {
 +            if (h->cabac.bytestream > h->cabac.bytestream_end + 2 )
 +                av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %td\n", h->cabac.bytestream_end - h->cabac.bytestream);
 +            if (ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 4) {
                  av_log(h->avctx, AV_LOG_ERROR,
                         "error while decoding MB %d %d, bytestream %td\n",
                         h->mb_x, h->mb_y,
                      tprintf(h->avctx, "slice end %d %d\n",
                              get_bits_count(&h->gb), h->gb.size_in_bits);
  
 -                    if (get_bits_left(&h->gb) == 0) {
 +                    if (   get_bits_left(&h->gb) == 0
 +                        || get_bits_left(&h->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
                          er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
                                       h->mb_x - 1, h->mb_y,
                                       ER_MB_END);
                          return 0;
                      } else {
                          er_add_slice(h, h->resync_mb_x, h->resync_mb_y,
 -                                     h->mb_x - 1, h->mb_y,
 +                                     h->mb_x, h->mb_y,
                                       ER_MB_END);
  
                          return AVERROR_INVALIDDATA;
@@@ -4744,21 -4528,20 +4745,21 @@@ static int execute_decode_slices(H264Co
      H264Context *hx;
      int i;
  
 -    if (h->mb_y >= h->mb_height) {
 -        av_log(h->avctx, AV_LOG_ERROR,
 -               "Input contains more MB rows than the frame height.\n");
 -        return AVERROR_INVALIDDATA;
 -    }
 +    av_assert0(h->mb_y < h->mb_height);
  
 -    if (h->avctx->hwaccel)
 +    if (h->avctx->hwaccel ||
 +        h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
          return 0;
      if (context_count == 1) {
          return decode_slice(avctx, &h);
      } else {
 +        av_assert0(context_count > 0);
          for (i = 1; i < context_count; i++) {
              hx                 = h->thread_context[i];
 -            hx->er.error_count = 0;
 +            if (CONFIG_ERROR_RESILIENCE) {
 +                hx->er.error_count = 0;
 +            }
 +            hx->x264_build     = h->x264_build;
          }
  
          avctx->execute(avctx, decode_slice, h->thread_context,
          h->mb_y              = hx->mb_y;
          h->droppable         = hx->droppable;
          h->picture_structure = hx->picture_structure;
 -        for (i = 1; i < context_count; i++)
 -            h->er.error_count += h->thread_context[i]->er.error_count;
 +        if (CONFIG_ERROR_RESILIENCE) {
 +            for (i = 1; i < context_count; i++)
 +                h->er.error_count += h->thread_context[i]->er.error_count;
 +        }
      }
  
      return 0;
  }
  
 +static const uint8_t start_code[] = { 0x00, 0x00, 0x01 };
 +
  static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size,
                              int parse_extradata)
  {
      int pass = !(avctx->active_thread_type & FF_THREAD_FRAME);
      int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
      int nal_index;
 +    int idr_cleared=0;
 +    int first_slice = 0;
      int ret = 0;
  
 +    h->nal_unit_type= 0;
 +
 +    if(!h->slice_context_count)
 +         h->slice_context_count= 1;
      h->max_contexts = h->slice_context_count;
      if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS)) {
          h->current_slice = 0;
          ff_h264_reset_sei(h);
      }
  
 +    if (h->nal_length_size == 4) {
 +        if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
 +            h->is_avc = 0;
 +        }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
 +            h->is_avc = 1;
 +    }
 +
      for (; pass <= 1; pass++) {
          buf_index     = 0;
          context_count = 0;
  
              if (h->avctx->debug & FF_DEBUG_STARTCODE)
                  av_log(h->avctx, AV_LOG_DEBUG,
 -                       "NAL %d at %d/%d length %d\n",
 -                       hx->nal_unit_type, buf_index, buf_size, dst_length);
 +                       "NAL %d/%d at %d/%d length %d pass %d\n",
 +                       hx->nal_unit_type, hx->nal_ref_idc, buf_index, buf_size, dst_length, pass);
  
              if (h->is_avc && (nalsize != consumed) && nalsize)
                  av_log(h->avctx, AV_LOG_DEBUG,
                  case NAL_IDR_SLICE:
                  case NAL_SLICE:
                      init_get_bits(&hx->gb, ptr, bit_length);
 -                    if (!get_ue_golomb(&hx->gb))
 +                    if (!get_ue_golomb(&hx->gb) ||
 +                        !first_slice ||
 +                        first_slice != hx->nal_unit_type)
                          nals_needed = nal_index;
 +                    if (!first_slice)
 +                        first_slice = hx->nal_unit_type;
                  }
                  continue;
              }
  
 +            if (!first_slice)
 +                switch (hx->nal_unit_type) {
 +                case NAL_DPA:
 +                case NAL_IDR_SLICE:
 +                case NAL_SLICE:
 +                    first_slice = hx->nal_unit_type;
 +                }
 +
              if (avctx->skip_frame >= AVDISCARD_NONREF &&
                  h->nal_ref_idc == 0 &&
                  h->nal_unit_type != NAL_SEI)
                  continue;
  
  again:
 -            /* Ignore every NAL unit type except PPS and SPS during extradata
 +            if (   !(avctx->active_thread_type & FF_THREAD_FRAME)
 +                || nals_needed >= nal_index)
 +                h->au_pps_id = -1;
 +            /* Ignore per frame NAL unit type during extradata
               * parsing. Decoding slices is not possible in codec init
               * with frame-mt */
 -            if (parse_extradata && HAVE_THREADS &&
 -                (h->avctx->active_thread_type & FF_THREAD_FRAME) &&
 -                (hx->nal_unit_type != NAL_PPS &&
 -                 hx->nal_unit_type != NAL_SPS)) {
 -                if (hx->nal_unit_type < NAL_AUD ||
 -                    hx->nal_unit_type > NAL_AUXILIARY_SLICE)
 -                    av_log(avctx, AV_LOG_INFO,
 -                           "Ignoring NAL unit %d during extradata parsing\n",
 +            if (parse_extradata) {
 +                switch (hx->nal_unit_type) {
 +                case NAL_IDR_SLICE:
 +                case NAL_SLICE:
 +                case NAL_DPA:
 +                case NAL_DPB:
 +                case NAL_DPC:
 +                    av_log(h->avctx, AV_LOG_WARNING,
 +                           "Ignoring NAL %d in global header/extradata\n",
                             hx->nal_unit_type);
 -                hx->nal_unit_type = NAL_FF_IGNORE;
 +                    // fall through to next case
 +                case NAL_AUXILIARY_SLICE:
 +                    hx->nal_unit_type = NAL_FF_IGNORE;
 +                }
              }
 +
              err = 0;
 +
              switch (hx->nal_unit_type) {
              case NAL_IDR_SLICE:
                  if (h->nal_unit_type != NAL_IDR_SLICE) {
                      ret = -1;
                      goto end;
                  }
 -                idr(h); // FIXME ensure we don't lose some frames if there is reordering
 +                if(!idr_cleared)
 +                    idr(h); // FIXME ensure we don't lose some frames if there is reordering
 +                idr_cleared = 1;
              case NAL_SLICE:
                  init_get_bits(&hx->gb, ptr, bit_length);
                  hx->intra_gb_ptr      =
                  if ((err = decode_slice_header(hx, h)))
                      break;
  
 -                if (h->sei_recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
 -                    h->recovery_frame = (h->frame_num + h->sei_recovery_frame_cnt) &
 -                                        ((1 << h->sps.log2_max_frame_num) - 1);
 +                if (h->sei_recovery_frame_cnt >= 0) {
 +                    if (h->frame_num != h->sei_recovery_frame_cnt || hx->slice_type_nos != AV_PICTURE_TYPE_I)
 +                        h->valid_recovery_point = 1;
 +
 +                    if (   h->recovery_frame < 0
 +                        || ((h->recovery_frame - h->frame_num) & ((1 << h->sps.log2_max_frame_num)-1)) > h->sei_recovery_frame_cnt) {
 +                        h->recovery_frame = (h->frame_num + h->sei_recovery_frame_cnt) &
 +                                            ((1 << h->sps.log2_max_frame_num) - 1);
 +
 +                        if (!h->valid_recovery_point)
 +                            h->recovery_frame = h->frame_num;
 +                    }
                  }
  
                  h->cur_pic_ptr->f.key_frame |=
 -                    (hx->nal_unit_type == NAL_IDR_SLICE) ||
 -                    (h->sei_recovery_frame_cnt >= 0);
 +                    (hx->nal_unit_type == NAL_IDR_SLICE);
  
                  if (hx->nal_unit_type == NAL_IDR_SLICE ||
                      h->recovery_frame == h->frame_num) {
                  // "recovered".
                  if (hx->nal_unit_type == NAL_IDR_SLICE)
                      h->frame_recovered |= FRAME_RECOVERED_IDR;
 +                h->frame_recovered |= 3*!!(avctx->flags2 & CODEC_FLAG2_SHOW_ALL);
 +                h->frame_recovered |= 3*!!(avctx->flags & CODEC_FLAG_OUTPUT_CORRUPT);
 +#if 1
 +                h->cur_pic_ptr->recovered |= h->frame_recovered;
 +#else
                  h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
 +#endif
  
                  if (h->current_slice == 1) {
                      if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS))
                      if (h->avctx->hwaccel &&
                          (ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0)) < 0)
                          return ret;
 +                    if (CONFIG_H264_VDPAU_DECODER &&
 +                        h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU)
 +                        ff_vdpau_h264_picture_start(h);
                  }
  
                  if (hx->redundant_pic_count == 0 &&
                                                             consumed);
                          if (ret < 0)
                              return ret;
 +                    } else if (CONFIG_H264_VDPAU_DECODER &&
 +                               h->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) {
 +                        ff_vdpau_add_data_chunk(h->cur_pic_ptr->f.data[0],
 +                                                start_code,
 +                                                sizeof(start_code));
 +                        ff_vdpau_add_data_chunk(h->cur_pic_ptr->f.data[0],
 +                                                &buf[buf_index - consumed],
 +                                                consumed);
                      } else
                          context_count++;
                  }
                  init_get_bits(&hx->inter_gb, ptr, bit_length);
                  hx->inter_gb_ptr = &hx->inter_gb;
  
 +                av_log(h->avctx, AV_LOG_ERROR, "Partitioned H.264 support is incomplete\n");
 +                break;
 +
                  if (hx->redundant_pic_count == 0 &&
                      hx->intra_gb_ptr &&
                      hx->data_partitioning &&
                  break;
              case NAL_SPS:
                  init_get_bits(&h->gb, ptr, bit_length);
 -                ret = ff_h264_decode_seq_parameter_set(h);
 -                if (ret < 0 && h->is_avc && (nalsize != consumed) && nalsize) {
 +                if (ff_h264_decode_seq_parameter_set(h) < 0 && (h->is_avc ? nalsize : 1)) {
                      av_log(h->avctx, AV_LOG_DEBUG,
                             "SPS decoding failure, trying again with the complete NAL\n");
 -                    init_get_bits(&h->gb, buf + buf_index + 1 - consumed,
 -                                  8 * (nalsize - 1));
 +                    if (h->is_avc)
 +                        av_assert0(next_avc - buf_index + consumed == nalsize);
 +                    if ((next_avc - buf_index + consumed - 1) >= INT_MAX/8)
 +                        break;
 +                    init_get_bits(&h->gb, &buf[buf_index + 1 - consumed],
 +                                  8*(next_avc - buf_index + consumed - 1));
                      ff_h264_decode_seq_parameter_set(h);
                  }
  
 -                ret = h264_set_parameter_from_sps(h);
 -                if (ret < 0)
 -                    goto end;
 -
                  break;
              case NAL_PPS:
                  init_get_bits(&h->gb, ptr, bit_length);
@@@ -5175,25 -4891,21 +5176,25 @@@ static int get_consumed_bytes(int pos, 
      return pos;
  }
  
 -static int output_frame(H264Context *h, AVFrame *dst, AVFrame *src)
 +static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
  {
 +    AVFrame *src = &srcp->f;
 +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format);
      int i;
      int ret = av_frame_ref(dst, src);
      if (ret < 0)
          return ret;
  
 -    if (!h->sps.crop)
 +    av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(h), 0);
 +
 +    if (!srcp->crop)
          return 0;
  
 -    for (i = 0; i < 3; i++) {
 -        int hshift = (i > 0) ? h->chroma_x_shift : 0;
 -        int vshift = (i > 0) ? h->chroma_y_shift : 0;
 -        int off    = ((h->sps.crop_left >> hshift) << h->pixel_shift) +
 -                     (h->sps.crop_top >> vshift) * dst->linesize[i];
 +    for (i = 0; i < desc->nb_components; i++) {
 +        int hshift = (i > 0) ? desc->log2_chroma_w : 0;
 +        int vshift = (i > 0) ? desc->log2_chroma_h : 0;
 +        int off    = ((srcp->crop_left >> hshift) << h->pixel_shift) +
 +                      (srcp->crop_top  >> vshift) * dst->linesize[i];
          dst->data[i] += off;
      }
      return 0;
@@@ -5207,8 -4919,6 +5208,8 @@@ static int h264_decode_frame(AVCodecCon
      H264Context *h     = avctx->priv_data;
      AVFrame *pict      = data;
      int buf_index      = 0;
 +    H264Picture *out;
 +    int i, out_idx;
      int ret;
  
      h->flags = avctx->flags;
      h->data_partitioning = 0;
  
      /* end of stream, output what is still in the buffers */
 -out:
      if (buf_size == 0) {
 -        H264Picture *out;
 -        int i, out_idx;
 + out:
  
          h->cur_pic_ptr = NULL;
 +        h->first_field = 0;
  
          // FIXME factorize this with the output code below
          out     = h->delayed_pic[0];
              h->delayed_pic[i] = h->delayed_pic[i + 1];
  
          if (out) {
 -            ret = output_frame(h, pict, &out->f);
 +            out->reference &= ~DELAYED_PIC_REF;
 +            ret = output_frame(h, pict, out);
              if (ret < 0)
                  return ret;
              *got_frame = 1;
  
          return buf_index;
      }
 +    if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){
 +        int cnt= buf[5]&0x1f;
 +        const uint8_t *p= buf+6;
 +        while(cnt--){
 +            int nalsize= AV_RB16(p) + 2;
 +            if(nalsize > buf_size - (p-buf) || p[2]!=0x67)
 +                goto not_extra;
 +            p += nalsize;
 +        }
 +        cnt = *(p++);
 +        if(!cnt)
 +            goto not_extra;
 +        while(cnt--){
 +            int nalsize= AV_RB16(p) + 2;
 +            if(nalsize > buf_size - (p-buf) || p[2]!=0x68)
 +                goto not_extra;
 +            p += nalsize;
 +        }
 +
 +        return ff_h264_decode_extradata(h, buf, buf_size);
 +    }
 +not_extra:
  
      buf_index = decode_nal_units(h, buf, buf_size, 0);
      if (buf_index < 0)
          return AVERROR_INVALIDDATA;
  
      if (!h->cur_pic_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
 -        buf_size = 0;
 +        av_assert0(buf_index <= buf_size);
          goto out;
      }
  
      if (!(avctx->flags2 & CODEC_FLAG2_CHUNKS) && !h->cur_pic_ptr) {
 -        if (avctx->skip_frame >= AVDISCARD_NONREF)
 -            return 0;
 +        if (avctx->skip_frame >= AVDISCARD_NONREF ||
 +            buf_size >= 4 && !memcmp("Q264", buf, 4))
 +            return buf_size;
          av_log(avctx, AV_LOG_ERROR, "no frame!\n");
          return AVERROR_INVALIDDATA;
      }
  
          field_end(h, 0);
  
 +        /* Wait for second field. */
          *got_frame = 0;
 -        if (h->next_output_pic && ((avctx->flags & CODEC_FLAG_OUTPUT_CORRUPT) ||
 +        if (h->next_output_pic && (
                                     h->next_output_pic->recovered)) {
              if (!h->next_output_pic->recovered)
                  h->next_output_pic->f.flags |= AV_FRAME_FLAG_CORRUPT;
  
 -            ret = output_frame(h, pict, &h->next_output_pic->f);
 +            ret = output_frame(h, pict, h->next_output_pic);
              if (ret < 0)
                  return ret;
              *got_frame = 1;
 +            if (CONFIG_MPEGVIDEO) {
 +                ff_print_debug_info2(h->avctx, h->next_output_pic, pict, h->er.mbskip_table,
 +                                    &h->low_delay,
 +                                    h->mb_width, h->mb_height, h->mb_stride, 1);
 +            }
          }
      }
  
@@@ -5337,7 -5018,6 +5338,7 @@@ static av_cold int h264_decode_end(AVCo
  {
      H264Context *h = avctx->priv_data;
  
 +    ff_h264_remove_all_refs(h);
      ff_h264_free_context(h);
  
      unref_picture(h, &h->cur_pic);
@@@ -5362,26 -5042,6 +5363,26 @@@ static const AVProfile profiles[] = 
      { FF_PROFILE_UNKNOWN },
  };
  
 +static const AVOption h264_options[] = {
 +    {"is_avc", "is avc", offsetof(H264Context, is_avc), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
 +    {"nal_length_size", "nal_length_size", offsetof(H264Context, nal_length_size), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0},
 +    {NULL}
 +};
 +
 +static const AVClass h264_class = {
 +    .class_name = "H264 Decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = h264_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +static const AVClass h264_vdpau_class = {
 +    .class_name = "H264 VDPAU Decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = h264_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_h264_decoder = {
      .name                  = "h264",
      .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
      .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
      .update_thread_context = ONLY_IF_THREADS_ENABLED(decode_update_thread_context),
      .profiles              = NULL_IF_CONFIG_SMALL(profiles),
 +    .priv_class            = &h264_class,
 +};
 +
 +#if CONFIG_H264_VDPAU_DECODER
 +AVCodec ff_h264_vdpau_decoder = {
 +    .name           = "h264_vdpau",
 +    .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_H264,
 +    .priv_data_size = sizeof(H264Context),
 +    .init           = ff_h264_decode_init,
 +    .close          = h264_decode_end,
 +    .decode         = h264_decode_frame,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
 +    .flush          = flush_dpb,
 +    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_VDPAU_H264,
 +                                                     AV_PIX_FMT_NONE},
 +    .profiles       = NULL_IF_CONFIG_SMALL(profiles),
 +    .priv_class     = &h264_vdpau_class,
  };
 +#endif
diff --combined libavcodec/h264.h
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "h264dsp.h"
  #include "h264pred.h"
  #include "h264qpel.h"
+ #include "mpegutils.h"
  #include "rectangle.h"
  
 -#define H264_MAX_PICTURE_COUNT 32
 -#define H264_MAX_THREADS       16
 +#define H264_MAX_PICTURE_COUNT 36
 +#define H264_MAX_THREADS       32
  
  #define MAX_SPS_COUNT          32
  #define MAX_PPS_COUNT         256
@@@ -50,8 -51,6 +51,8 @@@
  
  #define MAX_DELAYED_PIC_COUNT  16
  
 +#define MAX_MBPAIR_SIZE (256*1024) // a tighter bound could be calculated if someone cares about a few bytes
 +
  /* Compiling in interlaced support reduces the speed
   * of progressive decoding by about 2%. */
  #define ALLOW_INTERLACE
@@@ -91,7 -90,6 +92,7 @@@
  #define CABAC(h) h->pps.cabac
  #endif
  
 +#define CHROMA(h)    (h->sps.chroma_format_idc)
  #define CHROMA422(h) (h->sps.chroma_format_idc == 2)
  #define CHROMA444(h) (h->sps.chroma_format_idc == 3)
  
  #define IS_REF0(a)         ((a) & MB_TYPE_REF0)
  #define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
  
 -#define QP_MAX_NUM (51 + 2 * 6)           // The maximum supported qp
 +#define QP_MAX_NUM (51 + 6*6)           // The maximum supported qp
  
  /* NAL unit types */
  enum {
  typedef enum {
      SEI_TYPE_BUFFERING_PERIOD       = 0,   ///< buffering period (H.264, D.1.1)
      SEI_TYPE_PIC_TIMING             = 1,   ///< picture timing
 +    SEI_TYPE_USER_DATA_ITU_T_T35    = 4,   ///< user data registered by ITU-T Recommendation T.35
      SEI_TYPE_USER_DATA_UNREGISTERED = 5,   ///< unregistered user data
      SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
      SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
@@@ -151,19 -148,6 +152,19 @@@ typedef enum 
  } SEI_PicStructType;
  
  /**
 + * frame_packing_arrangement types
 + */
 +typedef enum {
 +    SEI_FPA_TYPE_CHECKERBOARD        = 0,
 +    SEI_FPA_TYPE_INTERLEAVE_COLUMN   = 1,
 +    SEI_FPA_TYPE_INTERLEAVE_ROW      = 2,
 +    SEI_FPA_TYPE_SIDE_BY_SIDE        = 3,
 +    SEI_FPA_TYPE_TOP_BOTTOM          = 4,
 +    SEI_FPA_TYPE_INTERLEAVE_TEMPORAL = 5,
 +    SEI_FPA_TYPE_2D                  = 6,
 +} SEI_FpaType;
 +
 +/**
   * Sequence parameter set
   */
  typedef struct SPS {
@@@ -247,23 -231,11 +248,23 @@@ typedef struct PPS 
      int transform_8x8_mode;         ///< transform_8x8_mode_flag
      uint8_t scaling_matrix4[6][16];
      uint8_t scaling_matrix8[6][64];
 -    uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
 +    uint8_t chroma_qp_table[2][QP_MAX_NUM+1];  ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
      int chroma_qp_diff;
  } PPS;
  
  /**
 + * Frame Packing Arrangement Type
 + */
 +typedef struct FPA {
 +    int         frame_packing_arrangement_id;
 +    int         frame_packing_arrangement_cancel_flag; ///< is previous arrangement canceled, -1 if never received
 +    SEI_FpaType frame_packing_arrangement_type;
 +    int         frame_packing_arrangement_repetition_period;
 +    int         content_interpretation_type;
 +    int         quincunx_sampling_flag;
 +} FPA;
 +
 +/**
   * Memory management control operation opcode.
   */
  typedef enum MMCOOpcode {
@@@ -320,11 -292,6 +321,11 @@@ typedef struct H264Picture 
      int needs_realloc;      ///< picture needs to be reallocated (eg due to a frame size change)
      int reference;
      int recovered;          ///< picture at IDR or recovery point + recovery count
 +    int invalid_gap;
 +
 +    int crop;
 +    int crop_left;
 +    int crop_top;
  } H264Picture;
  
  /**
   */
  typedef struct H264Context {
      AVCodecContext *avctx;
 -    DSPContext       dsp;
      VideoDSPContext vdsp;
      H264DSPContext h264dsp;
      H264ChromaContext h264chroma;
      H264QpelContext h264qpel;
      ParseContext parse_context;
      GetBitContext gb;
 +    DSPContext       dsp;
      ERContext er;
  
      H264Picture *DPB;
      ptrdiff_t mb_linesize;  ///< may be equal to s->linesize or s->linesize * 2, for mbaff
      ptrdiff_t mb_uvlinesize;
  
 +    unsigned current_sps_id; ///< id of the current SPS
      SPS sps; ///< current sps
      PPS pps; ///< current pps
  
 +    int au_pps_id; ///< pps_id of current access unit
 +
      uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16]; // FIXME should these be moved down?
      uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
      uint32_t(*dequant4_coeff[6])[16];
      uint8_t field_scan[16];
      uint8_t field_scan8x8[64];
      uint8_t field_scan8x8_cavlc[64];
 -    const uint8_t *zigzag_scan_q0;
 -    const uint8_t *zigzag_scan8x8_q0;
 -    const uint8_t *zigzag_scan8x8_cavlc_q0;
 -    const uint8_t *field_scan_q0;
 -    const uint8_t *field_scan8x8_q0;
 -    const uint8_t *field_scan8x8_cavlc_q0;
 +    uint8_t zigzag_scan_q0[16];
 +    uint8_t zigzag_scan8x8_q0[64];
 +    uint8_t zigzag_scan8x8_cavlc_q0[64];
 +    uint8_t field_scan_q0[16];
 +    uint8_t field_scan8x8_q0[64];
 +    uint8_t field_scan8x8_cavlc_q0[64];
  
      int x264_build;
  
      struct H264Context *thread_context[H264_MAX_THREADS];
  
      /**
 -     * current slice number, used to initalize slice_num of each thread/context
 +     * current slice number, used to initialize slice_num of each thread/context
       */
      int current_slice;
  
      enum AVPictureType pict_type;
  
      int last_slice_type;
 +    unsigned int last_ref_count[2];
      /** @} */
  
      /**
      int sei_recovery_frame_cnt;
  
      /**
 +     * Are the SEI recovery points looking valid.
 +     */
 +    int valid_recovery_point;
 +
 +    FPA sei_fpa;
 +
 +    /**
       * recovery_frame is the frame_num at which the next frame should
       * be fully constructed.
       *
  
      int cur_chroma_format_idc;
      uint8_t *bipred_scratchpad;
 +
 +    int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 +
 +    uint8_t parse_history[4];
 +    int parse_history_count;
 +    int parse_last_mb;
      uint8_t *edge_emu_buffer;
      int16_t *dc_val_base;
  
      qpel_mc_func (*qpel_avg)[16];
  } H264Context;
  
 -extern const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1]; ///< One chroma qp table for each supported bit depth (8, 9, 10).
 +extern const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1]; ///< One chroma qp table for each possible bit depth (8-14).
  extern const uint16_t ff_h264_mb_sizes[4];
  
  /**
@@@ -833,7 -783,7 +834,7 @@@ int ff_h264_check_intra4x4_pred_mode(H2
  int ff_h264_check_intra_pred_mode(H264Context *h, int mode, int is_chroma);
  
  void ff_h264_hl_decode_mb(H264Context *h);
 -int ff_h264_decode_extradata(H264Context *h);
 +int ff_h264_decode_extradata(H264Context *h, const uint8_t *buf, int size);
  int ff_h264_decode_init(AVCodecContext *avctx);
  void ff_h264_decode_init_vlc(void);
  
@@@ -869,12 -819,6 +870,12 @@@ void ff_h264_filter_mb(H264Context *h, 
   */
  void ff_h264_reset_sei(H264Context *h);
  
 +/**
 + * Get stereo_mode string from the h264 frame_packing_arrangement
 + * @param h H.264 context.
 + */
 +const char* ff_h264_sei_stereo_mode(H264Context *h);
 +
  /*
   * o-o o-o
   *  / / /
diff --combined libavcodec/h264_cabac.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... cabac decoding
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   */
  
  #define CABAC(h) 1
 +#define UNCHECKED_BITSTREAM_READER 1
  
  #include "libavutil/attributes.h"
++#include "libavutil/avassert.h"
  #include "libavutil/timer.h"
  #include "config.h"
  #include "cabac.h"
  #include "h264data.h"
  #include "h264_mvpred.h"
  #include "golomb.h"
- #include "libavutil/avassert.h"
+ #include "mpegutils.h"
  
  #if ARCH_X86
  #include "x86/h264_i386.h"
  #endif
  
 -#include <assert.h>
 -
  /* Cabac pre state table */
  
  static const int8_t cabac_context_init_I[1024][2] =
@@@ -1620,9 -1621,7 +1621,9 @@@ decode_cabac_residual_internal(H264Cont
      cc.range     = h->cabac.range;
      cc.low       = h->cabac.low;
      cc.bytestream= h->cabac.bytestream;
 +#if !UNCHECKED_BITSTREAM_READER || ARCH_AARCH64
      cc.bytestream_end = h->cabac.bytestream_end;
 +#endif
  #else
  #define CC &h->cabac
  #endif
          }
  #endif
      }
 -    assert(coeff_count > 0);
 +    av_assert2(coeff_count > 0);
  
      if( is_dc ) {
          if( cat == 3 )
          if( max_coeff == 64 )
              fill_rectangle(&h->non_zero_count_cache[scan8[n]], 2, 2, 8, coeff_count, 1);
          else {
 -            assert( cat == 1 || cat ==  2 || cat ==  4 || cat == 7 || cat == 8 || cat == 11 || cat == 12 );
 +            av_assert2( cat == 1 || cat ==  2 || cat ==  4 || cat == 7 || cat == 8 || cat == 11 || cat == 12 );
              h->non_zero_count_cache[scan8[n]] = coeff_count;
          }
      }
  \
              if( coeff_abs >= 15 ) { \
                  int j = 0; \
 -                while( get_cabac_bypass( CC ) ) { \
 +                while(get_cabac_bypass( CC ) && j<30) { \
                      j++; \
                  } \
  \
@@@ -1886,7 -1885,6 +1887,7 @@@ int ff_h264_decode_mb_cabac(H264Contex
      int dct8x8_allowed= h->pps.transform_8x8_mode;
      int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
 +    unsigned local_ref_count[2];
  
      mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
  
  
      if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
          int ctx = 0;
 -        assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
 +        av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_B);
  
          if( !IS_DIRECT( h->left_type[LTOP]-1 ) )
              ctx++;
          mb_type= decode_cabac_intra_mb_type(h, 3, 1);
          if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
              mb_type--;
 -        assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
 +        av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
  decode_intra_mb:
          partition_count = 0;
          cbp= i_mb_type_info[mb_type].cbp;
          return 0;
      }
  
 +    local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
 +    local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
 +
      fill_decode_caches(h, mb_type);
  
      if( IS_INTRA( mb_type ) ) {
                  for( i = 0; i < 4; i++ ) {
                      if(IS_DIRECT(h->sub_mb_type[i])) continue;
                      if(IS_DIR(h->sub_mb_type[i], 0, list)){
 -                        int rc = h->ref_count[list] << MB_MBAFF(h);
 -                        if (rc > 1) {
 +                        if (local_ref_count[list] > 1) {
                              ref[list][i] = decode_cabac_mb_ref( h, list, 4*i );
 -                            if (ref[list][i] >= (unsigned) rc) {
 -                                av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], rc);
 +                            if (ref[list][i] >= (unsigned)local_ref_count[list]) {
 +                                av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], local_ref_count[list]);
                                  return -1;
                              }
                          }else
          if(IS_16X16(mb_type)){
              for(list=0; list<h->list_count; list++){
                  if(IS_DIR(mb_type, 0, list)){
 -                    int ref, rc = h->ref_count[list] << MB_MBAFF(h);
 -                    if (rc > 1) {
 +                    int ref;
 +                    if (local_ref_count[list] > 1) {
                          ref= decode_cabac_mb_ref(h, list, 0);
 -                        if (ref >= (unsigned) rc) {
 -                            av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
 +                        if (ref >= (unsigned)local_ref_count[list]) {
 +                            av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, local_ref_count[list]);
                              return -1;
                          }
                      }else
              for(list=0; list<h->list_count; list++){
                      for(i=0; i<2; i++){
                          if(IS_DIR(mb_type, i, list)){
 -                            int ref, rc = h->ref_count[list] << MB_MBAFF(h);
 -                            if (rc > 1) {
 +                            int ref;
 +                            if (local_ref_count[list] > 1) {
                                  ref= decode_cabac_mb_ref( h, list, 8*i );
 -                                if (ref >= (unsigned) rc) {
 -                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
 +                                if (ref >= (unsigned)local_ref_count[list]) {
 +                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, local_ref_count[list]);
                                      return -1;
                                  }
                              }else
                  }
              }
          }else{
 -            assert(IS_8X16(mb_type));
 +            av_assert2(IS_8X16(mb_type));
              for(list=0; list<h->list_count; list++){
                      for(i=0; i<2; i++){
                          if(IS_DIR(mb_type, i, list)){ //FIXME optimize
 -                            int ref, rc = h->ref_count[list] << MB_MBAFF(h);
 -                            if (rc > 1) {
 +                            int ref;
 +                            if (local_ref_count[list] > 1) {
                                  ref= decode_cabac_mb_ref( h, list, 4*i );
 -                                if (ref >= (unsigned) rc) {
 -                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
 +                                if (ref >= (unsigned)local_ref_count[list]) {
 +                                    av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, local_ref_count[list]);
                                      return -1;
                                  }
                              }else
          cbp  = decode_cabac_mb_cbp_luma( h );
          if(decode_chroma)
              cbp |= decode_cabac_mb_cbp_chroma( h ) << 4;
 +    } else {
 +        if (!decode_chroma && cbp>15) {
 +            av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
 +            return AVERROR_INVALIDDATA;
 +        }
      }
  
      h->cbp_table[mb_xy] = h->cbp = cbp;
diff --combined libavcodec/h264_cavlc.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -26,7 -26,6 +26,7 @@@
   */
  
  #define CABAC(h) 0
 +#define UNCHECKED_BITSTREAM_READER 1
  
  #include "internal.h"
  #include "avcodec.h"
@@@ -35,8 -34,9 +35,9 @@@
  #include "h264data.h" // FIXME FIXME FIXME
  #include "h264_mvpred.h"
  #include "golomb.h"
+ #include "mpegutils.h"
 +#include "libavutil/avassert.h"
  
 -#include <assert.h>
  
  static const uint8_t golomb_to_inter_cbp_gray[16]={
   0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
@@@ -360,7 -360,7 +361,7 @@@ av_cold void ff_h264_decode_init_vlc(vo
           * the packed static coeff_token_vlc table sizes
           * were initialized correctly.
           */
 -        assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
 +        av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
  
          for(i=0; i<3; i++){
              chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
@@@ -479,7 -479,7 +480,7 @@@ static int decode_residual(H264Context 
  
      trailing_ones= coeff_token&3;
      tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
 -    assert(total_coeff<=16);
 +    av_assert2(total_coeff<=16);
  
      i = show_bits(gb, 3);
      skip_bits(gb, trailing_ones);
                  else
                      level_code= prefix + get_bits(gb, 4); //part
              }else{
 -                level_code= 30 + get_bits(gb, prefix-3); //part
 +                level_code= 30;
                  if(prefix>=16){
                      if(prefix > 25+3){
                          av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
                      }
                      level_code += (1<<(prefix-3))-4096;
                  }
 +                level_code += get_bits(gb, prefix-3); //part
              }
  
              if(trailing_ones < 3) level_code += 2;
                  if(prefix<15){
                      level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
                  }else{
 -                    level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
 -                    if(prefix>=16)
 +                    level_code = 15<<suffix_length;
 +                    if (prefix>=16) {
 +                        if(prefix > 25+3){
 +                            av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
 +                            return AVERROR_INVALIDDATA;
 +                        }
                          level_code += (1<<(prefix-3))-4096;
 +                    }
 +                    level_code += get_bits(gb, prefix-3);
                  }
                  mask= -(level_code&1);
                  level_code= (((2+level_code)>>1) ^ mask) - mask;
      else{
          if (max_coeff <= 8) {
              if (max_coeff == 4)
 -                zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
 +                zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
                                        CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
              else
 -                zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
 +                zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
                                        CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
          } else {
 -            zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
 +            zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
          }
      }
  
          ((type*)block)[*scantable] = level[0]; \
          for(i=1;i<total_coeff && zeros_left > 0;i++) { \
              if(zeros_left < 7) \
 -                run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 +                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
              else \
                  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
              zeros_left -= run_before; \
          ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
          for(i=1;i<total_coeff && zeros_left > 0;i++) { \
              if(zeros_left < 7) \
 -                run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 +                run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
              else \
                  run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
              zeros_left -= run_before; \
          } \
      }
  
 -    if (zeros_left < 0) {
 -        av_log(h->avctx, AV_LOG_ERROR,
 -               "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
 -        return AVERROR_INVALIDDATA;
 -    }
 -
      if (h->pixel_shift) {
          STORE_BLOCK(int32_t)
      } else {
          STORE_BLOCK(int16_t)
      }
  
 +    if(zeros_left<0){
 +        av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
 +        return -1;
 +    }
 +
      return 0;
  }
  
@@@ -642,7 -636,7 +643,7 @@@ static av_always_inline int decode_luma
              return -1; //FIXME continue if partitioned and other return -1 too
          }
  
 -        assert((cbp&15) == 0 || (cbp&15) == 15);
 +        av_assert2((cbp&15) == 0 || (cbp&15) == 15);
  
          if(cbp&15){
              for(i8x8=0; i8x8<4; i8x8++){
@@@ -703,7 -697,6 +704,7 @@@ int ff_h264_decode_mb_cavlc(H264Contex
      int dct8x8_allowed= h->pps.transform_8x8_mode;
      int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
 +    unsigned local_ref_count[2];
  
      mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
  
                  down the code */
      if(h->slice_type_nos != AV_PICTURE_TYPE_I){
          if(h->mb_skip_run==-1)
 -            h->mb_skip_run= get_ue_golomb(&h->gb);
 +            h->mb_skip_run= get_ue_golomb_long(&h->gb);
  
          if (h->mb_skip_run--) {
              if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
              goto decode_intra_mb;
          }
      }else{
 -       assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
 +       av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
          if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
              mb_type--;
  decode_intra_mb:
          return 0;
      }
  
 +    local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
 +    local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
 +
      fill_decode_neighbors(h, mb_type);
      fill_decode_caches(h, mb_type);
  
                  h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
              }
          }else{
 -            assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
 +            av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
              for(i=0; i<4; i++){
                  h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
                  if(h->sub_mb_type[i] >=4){
          }
  
          for(list=0; list<h->list_count; list++){
 -            int ref_count = IS_REF0(mb_type) ? 1 : h->ref_count[list] << MB_MBAFF(h);
 +            int ref_count = IS_REF0(mb_type) ? 1 : local_ref_count[list];
              for(i=0; i<4; i++){
                  if(IS_DIRECT(h->sub_mb_type[i])) continue;
                  if(IS_DIR(h->sub_mb_type[i], 0, list)){
              for(list=0; list<h->list_count; list++){
                      unsigned int val;
                      if(IS_DIR(mb_type, 0, list)){
 -                        int rc = h->ref_count[list] << MB_MBAFF(h);
 -                        if (rc == 1) {
 +                        if(local_ref_count[list]==1){
                              val= 0;
 -                        } else if (rc == 2) {
 +                        } else if(local_ref_count[list]==2){
                              val= get_bits1(&h->gb)^1;
                          }else{
                              val= get_ue_golomb_31(&h->gb);
 -                            if (val >= rc) {
 +                            if (val >= local_ref_count[list]){
                                  av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                  return -1;
                              }
                      for(i=0; i<2; i++){
                          unsigned int val;
                          if(IS_DIR(mb_type, i, list)){
 -                            int rc = h->ref_count[list] << MB_MBAFF(h);
 -                            if (rc == 1) {
 +                            if(local_ref_count[list] == 1) {
                                  val= 0;
 -                            } else if (rc == 2) {
 +                            } else if(local_ref_count[list] == 2) {
                                  val= get_bits1(&h->gb)^1;
                              }else{
                                  val= get_ue_golomb_31(&h->gb);
 -                                if (val >= rc) {
 +                                if (val >= local_ref_count[list]){
                                      av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                      return -1;
                                  }
                  }
              }
          }else{
 -            assert(IS_8X16(mb_type));
 +            av_assert2(IS_8X16(mb_type));
              for(list=0; list<h->list_count; list++){
                      for(i=0; i<2; i++){
                          unsigned int val;
                          if(IS_DIR(mb_type, i, list)){ //FIXME optimize
 -                            int rc = h->ref_count[list] << MB_MBAFF(h);
 -                            if (rc == 1) {
 +                            if(local_ref_count[list]==1){
                                  val= 0;
 -                            } else if (rc == 2) {
 +                            } else if(local_ref_count[list]==2){
                                  val= get_bits1(&h->gb)^1;
                              }else{
                                  val= get_ue_golomb_31(&h->gb);
 -                                if (val >= rc) {
 +                                if (val >= local_ref_count[list]){
                                      av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
                                      return -1;
                                  }
              if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
              else                     cbp= golomb_to_inter_cbp_gray[cbp];
          }
 +    } else {
 +        if (!decode_chroma && cbp>15) {
 +            av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
 +            return AVERROR_INVALIDDATA;
 +        }
      }
  
      if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
              if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
                  return -1;
              }
 -        } else if (CHROMA422(h)) {
 +        } else {
 +            const int num_c8x8 = h->sps.chroma_format_idc;
 +
              if(cbp&0x30){
                  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
                      if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
 -                                        CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
 -                                        NULL, 8) < 0) {
 +                                        CHROMA_DC_BLOCK_INDEX+chroma_idx,
 +                                        CHROMA422(h) ? chroma422_dc_scan : chroma_dc_scan,
 +                                        NULL, 4*num_c8x8) < 0) {
                          return -1;
                      }
              }
                  for(chroma_idx=0; chroma_idx<2; chroma_idx++){
                      const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
                      int16_t *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
 -                    for (i8x8 = 0; i8x8 < 2; i8x8++) {
 +                    for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
                          for (i4x4 = 0; i4x4 < 4; i4x4++) {
                              const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
                              if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
                  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
                  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
              }
 -        } else /* yuv420 */ {
 -            if(cbp&0x30){
 -                for(chroma_idx=0; chroma_idx<2; chroma_idx++)
 -                    if( decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){
 -                        return -1;
 -                    }
 -            }
 -
 -            if(cbp&0x20){
 -                for(chroma_idx=0; chroma_idx<2; chroma_idx++){
 -                    const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
 -                    for(i4x4=0; i4x4<4; i4x4++){
 -                        const int index= 16 + 16*chroma_idx + i4x4;
 -                        if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
 -                            return -1;
 -                        }
 -                    }
 -                }
 -            }else{
 -                fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
 -                fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
 -            }
          }
      }else{
          fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
diff --combined libavcodec/h264_direct.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... direct mb/block decoding
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -29,6 -29,7 +29,7 @@@
  #include "avcodec.h"
  #include "mpegvideo.h"
  #include "h264.h"
+ #include "mpegutils.h"
  #include "rectangle.h"
  #include "thread.h"
  
@@@ -208,7 -209,6 +209,7 @@@ static void pred_spatial_direct_motion(
                      mv[list]= AV_RN32A(C);
                  }
              }
 +            av_assert2(ref[list] < (h->ref_count[list] << !!FRAME_MBAFF(h)));
          }else{
              int mask= ~(MB_TYPE_L0 << (2*list));
              mv[list] = 0;
@@@ -288,8 -288,8 +289,8 @@@ single_col
  
      await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
  
 -    l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
 -    l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
 +    l1mv0  = (void*)&h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
 +    l1mv1  = (void*)&h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
      l1ref0 = &h->ref_list[1][0].ref_index [0][4 * mb_xy];
      l1ref1 = &h->ref_list[1][0].ref_index [1][4 * mb_xy];
      if(!b8_stride){
@@@ -478,8 -478,8 +479,8 @@@ single_col
  
      await_reference_mb_row(h, &h->ref_list[1][0], mb_y);
  
 -    l1mv0  = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
 -    l1mv1  = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
 +    l1mv0  = (void*)&h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]];
 +    l1mv1  = (void*)&h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]];
      l1ref0 = &h->ref_list[1][0].ref_index [0][4 * mb_xy];
      l1ref1 = &h->ref_list[1][0].ref_index [1][4 * mb_xy];
      if(!b8_stride){
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... loop filter
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "mpegvideo.h"
  #include "h264.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "rectangle.h"
  
 -#include <assert.h>
 -
  /* Deblocking filter (p153) */
  static const uint8_t alpha_table[52*3] = {
       0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
@@@ -241,7 -244,7 +242,7 @@@ static av_always_inline void h264_filte
                                                            unsigned int uvlinesize,
                                                            int pixel_shift)
  {
 -    int chroma = !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
 +    int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
      int chroma444 = CHROMA444(h);
      int chroma422 = CHROMA422(h);
  
  }
  
  void ff_h264_filter_mb_fast( H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize) {
 -    assert(!FRAME_MBAFF(h));
 +    av_assert2(!FRAME_MBAFF(h));
      if(!h->h264dsp.h264_loop_filter_strength || h->pps.chroma_qp_diff) {
          ff_h264_filter_mb(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
          return;
@@@ -578,9 -581,7 +579,9 @@@ static av_always_inline void filter_mb_
              // value in IPCM macroblocks.
              if(bS[0]+bS[1]+bS[2]+bS[3]){
                  qp = (h->cur_pic.qscale_table[mb_xy] + h->cur_pic.qscale_table[mbm_xy] + 1) >> 1;
 +                //tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
                  tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
 +                //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
                  chroma_qp_avg[0] = (h->chroma_qp[0] + get_chroma_qp(h, 0, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  chroma_qp_avg[1] = (h->chroma_qp[1] + get_chroma_qp(h, 1, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  if( dir == 0 ) {
          // Do not use s->qscale as luma quantizer because it has not the same
          // value in IPCM macroblocks.
          qp = h->cur_pic.qscale_table[mb_xy];
 +        //tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d, QPc:%d, QPcn:%d\n", mb_x, mb_y, dir, edge, qp, h->chroma_qp[0], h->cur_pic.qscale_table[mbn_xy]);
          tprintf(h->avctx, "filter mb:%d/%d dir:%d edge:%d, QPy:%d ls:%d uvls:%d", mb_x, mb_y, dir, edge, qp, linesize, uvlinesize);
 +        //{ int i; for (i = 0; i < 4; i++) tprintf(h->avctx, " bS[%d]:%d", i, bS[i]); tprintf(h->avctx, "\n"); }
          if( dir == 0 ) {
              filter_mb_edgev( &img_y[4*edge << h->pixel_shift], linesize, bS, qp, a, b, h, 0 );
              if (chroma) {
@@@ -707,7 -706,7 +708,7 @@@ void ff_h264_filter_mb( H264Context *h
      const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
      int first_vertical_edge_done = 0;
      av_unused int dir;
 -    int chroma = !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
 +    int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY));
      int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
      int a = 52 + h->slice_alpha_c0_offset - qp_bd_offset;
      int b = 52 + h->slice_beta_offset - qp_bd_offset;
diff --combined libavcodec/h264_mvpred.h
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... motion vector predicion
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -31,8 -31,9 +31,9 @@@
  #include "internal.h"
  #include "avcodec.h"
  #include "h264.h"
+ #include "mpegutils.h"
 +#include "libavutil/avassert.h"
  
 -#include <assert.h>
  
  static av_always_inline int fetch_diagonal_mv(H264Context *h, const int16_t **C,
                                                int i, int list, int part_width)
@@@ -102,7 -103,7 +103,7 @@@ static av_always_inline void pred_motio
      const int16_t *C;
      int diagonal_ref, match_count;
  
 -    assert(part_width == 1 || part_width == 2 || part_width == 4);
 +    av_assert2(part_width == 1 || part_width == 2 || part_width == 4);
  
  /* mv_cache
   * B . . A T T T T
@@@ -481,7 -482,7 +482,7 @@@ static void fill_decode_caches(H264Cont
                  } else {
                      int left_typei = h->cur_pic.mb_type[left_xy[LTOP] + h->mb_stride];
  
 -                    assert(left_xy[LTOP] == left_xy[LBOT]);
 +                    av_assert2(left_xy[LTOP] == left_xy[LBOT]);
                      if (!((left_typei & type_mask) && (left_type[LTOP] & type_mask))) {
                          h->topleft_samples_available &= 0xDF5F;
                          h->left_samples_available    &= 0x5F5F;
              int16_t(*mv)[2]       = h->cur_pic.motion_val[list];
              if (!USES_LIST(mb_type, list))
                  continue;
 -            assert(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));
 +            av_assert2(!(IS_DIRECT(mb_type) && !h->direct_spatial_mv_pred));
  
              if (USES_LIST(top_type, list)) {
                  const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;
                  ref_cache[4 - 1 * 8] = topright_type ? LIST_NOT_USED
                                                       : PART_NOT_AVAILABLE;
              }
 -            if (ref_cache[4 - 1 * 8] < 0) {
 +            if(ref_cache[2 - 1*8] < 0 || ref_cache[4 - 1 * 8] < 0) {
                  if (USES_LIST(topleft_type, list)) {
                      const int b_xy  = h->mb2b_xy[topleft_xy] + 3 + b_stride +
                                        (h->topleft_partition & 2 * b_stride);
diff --combined libavcodec/h264_parser.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... parser
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
 +
  #include "libavutil/attributes.h"
  #include "parser.h"
  #include "h264data.h"
  #include "golomb.h"
  #include "internal.h"
+ #include "mpegutils.h"
  
 -#include <assert.h>
 -
  
  static int h264_find_frame_end(H264Context *h, const uint8_t *buf,
                                 int buf_size)
  {
 -    int i;
 +    int i, j;
      uint32_t state;
      ParseContext *pc = &h->parse_context;
 +    int next_avc= h->is_avc ? 0 : buf_size;
 +
  //    mb_addr= pc->mb_addr - 1;
      state = pc->state;
      if (state > 13)
          state = 7;
  
 +    if (h->is_avc && !h->nal_length_size)
 +        av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");
 +
      for (i = 0; i < buf_size; i++) {
 +        if (i >= next_avc) {
 +            int nalsize = 0;
 +            i = next_avc;
 +            for (j = 0; j < h->nal_length_size; j++)
 +                nalsize = (nalsize << 8) | buf[i++];
 +            if (nalsize <= 0 || nalsize > buf_size - i) {
 +                av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i);
 +                return buf_size;
 +            }
 +            next_avc = i + nalsize;
 +            state    = 5;
 +        }
 +
          if (state == 7) {
 -            i += h->h264dsp.h264_find_start_code_candidate(buf + i, buf_size - i);
 -            if (i < buf_size)
 +            i += h->h264dsp.h264_find_start_code_candidate(buf + i, next_avc - i);
 +            if (i < next_avc)
                  state = 2;
          } else if (state <= 2) {
              if (buf[i] == 1)
                  }
              } else if (nalu_type == NAL_SLICE || nalu_type == NAL_DPA ||
                         nalu_type == NAL_IDR_SLICE) {
 +                state += 8;
 +                continue;
 +            }
 +            state = 7;
 +        } else {
 +            h->parse_history[h->parse_history_count++]= buf[i];
 +            if (h->parse_history_count>3) {
 +                unsigned int mb, last_mb= h->parse_last_mb;
 +                GetBitContext gb;
 +
 +                init_get_bits(&gb, h->parse_history, 8*h->parse_history_count);
 +                h->parse_history_count=0;
 +                mb= get_ue_golomb_long(&gb);
 +                last_mb= h->parse_last_mb;
 +                h->parse_last_mb= mb;
                  if (pc->frame_start_found) {
 -                    state += 8;
 -                    continue;
 +                    if (mb <= last_mb)
 +                        goto found;
                  } else
                      pc->frame_start_found = 1;
 +                state = 7;
              }
 -            state = 7;
 -        } else {
 -            if (buf[i] & 0x80)
 -                goto found;
 -            state = 7;
          }
      }
      pc->state = state;
 +    if (h->is_avc)
 +        return next_avc;
      return END_NOT_FOUND;
  
  found:
      pc->state             = 7;
      pc->frame_start_found = 0;
 -    return i - (state & 5);
 +    if (h->is_avc)
 +        return next_avc;
 +    return i - (state & 5) - 3 * (state > 7);
  }
  
  static int scan_mmco_reset(AVCodecParserContext *s)
@@@ -210,7 -178,6 +211,7 @@@ static inline int parse_nal_units(AVCod
      unsigned int slice_type;
      int state = -1, got_reset = 0;
      const uint8_t *ptr;
 +    int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
      int field_poc[2];
  
      /* set some sane default values */
  
      h->avctx = avctx;
      ff_h264_reset_sei(h);
 +    h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
  
      if (!buf_size)
          return 0;
  
      for (;;) {
 -        int src_length, dst_length, consumed;
 +        int src_length, dst_length, consumed, nalsize = 0;
 +        if (h->is_avc) {
 +            int i;
 +            if (h->nal_length_size >= buf_end - buf) break;
 +            nalsize = 0;
 +            for (i = 0; i < h->nal_length_size; i++)
 +                nalsize = (nalsize << 8) | *buf++;
 +            if (nalsize <= 0 || nalsize > buf_end - buf) {
 +                av_log(h->avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize);
 +                break;
 +            }
 +            src_length = nalsize;
 +        } else {
          buf = avpriv_find_start_code(buf, buf_end, &state);
          if (buf >= buf_end)
              break;
          --buf;
          src_length = buf_end - buf;
 +        }
          switch (state & 0x1f) {
          case NAL_SLICE:
          case NAL_IDR_SLICE:
              h->prev_poc_lsb          = 0;
          /* fall through */
          case NAL_SLICE:
 -            get_ue_golomb(&h->gb);  // skip first_mb_in_slice
 +            get_ue_golomb_long(&h->gb);  // skip first_mb_in_slice
              slice_type   = get_ue_golomb_31(&h->gb);
              s->pict_type = golomb_to_pict_type[slice_type % 5];
              if (h->sei_recovery_frame_cnt >= 0) {
              h->sps       = *h->sps_buffers[h->pps.sps_id];
              h->frame_num = get_bits(&h->gb, h->sps.log2_max_frame_num);
  
 +            if(h->sps.ref_frame_count <= 1 && h->pps.ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
 +                s->key_frame = 1;
 +
              avctx->profile = ff_h264_get_profile(&h->sps);
              avctx->level   = h->sps.level_idc;
  
  
              return 0; /* no need to evaluate the rest */
          }
 -        buf += consumed;
 +        buf += h->is_avc ? nalsize : consumed;
      }
 +    if (q264)
 +        return 0;
      /* didn't find a picture! */
 -    av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit\n");
 +    av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
      return -1;
  }
  
@@@ -461,13 -409,14 +462,13 @@@ static int h264_parse(AVCodecParserCont
          h->got_first = 1;
          if (avctx->extradata_size) {
              h->avctx = avctx;
 -            // must be done like in the decoder.
 -            // otherwise opening the parser, creating extradata,
 -            // and then closing and opening again
 +            // must be done like in decoder, otherwise opening the parser,
 +            // letting it create extradata and then closing and opening again
              // will cause has_b_frames to be always set.
 -            // NB: estimate_timings_from_pts behaves exactly like this.
 +            // Note that estimate_timings_from_pts does exactly this.
              if (!avctx->has_b_frames)
                  h->low_delay = 1;
 -            ff_h264_decode_extradata(h);
 +            ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);
          }
      }
  
          }
  
          if (next < 0 && next != END_NOT_FOUND) {
 -            assert(pc->last_index + next >= 0);
 +            av_assert1(pc->last_index + next >= 0);
              h264_find_frame_end(h, &pc->buffer[pc->last_index + next], -next); // update state
          }
      }
@@@ -519,7 -468,7 +520,7 @@@ static int h264_split(AVCodecContext *a
      for (i = 0; i <= buf_size; i++) {
          if ((state & 0xFFFFFF1F) == 0x107)
              has_sps = 1;
 -        /*  if((state&0xFFFFFF1F) == 0x101 ||
 +        /*  if ((state&0xFFFFFF1F) == 0x101 ||
           *     (state&0xFFFFFF1F) == 0x102 ||
           *     (state&0xFFFFFF1F) == 0x105) {
           *  }
diff --combined libavcodec/h264_refs.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#include "libavutil/avassert.h"
  #include "internal.h"
  #include "avcodec.h"
  #include "h264.h"
  #include "golomb.h"
+ #include "mpegutils.h"
  
  #include <assert.h>
  
@@@ -74,18 -74,16 +75,18 @@@ static int build_def_list(H264Picture *
      int  i[2] = { 0 };
      int index = 0;
  
 -    while ((i[0] < len || i[1] < len) && index < def_len) {
 +    while (i[0] < len || i[1] < len) {
          while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
              i[0]++;
          while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
              i[1]++;
 -        if (i[0] < len && index < def_len) {
 +        if (i[0] < len) {
 +            av_assert0(index < def_len);
              in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
              split_field_copy(&def[index++], in[i[0]++], sel, 1);
          }
 -        if (i[1] < len && index < def_len) {
 +        if (i[1] < len) {
 +            av_assert0(index < def_len);
              in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
              split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
          }
@@@ -133,14 -131,13 +134,14 @@@ int ff_h264_fill_default_ref_list(H264C
          for (list = 0; list < 2; list++) {
              len  = add_sorted(sorted,       h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
              len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
 -            assert(len <= 32);
 +            av_assert0(len <= 32);
  
              len  = build_def_list(h->default_ref_list[list], FF_ARRAY_ELEMS(h->default_ref_list[0]),
                                    sorted, len, 0, h->picture_structure);
              len += build_def_list(h->default_ref_list[list] + len,
                                    FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
                                    h->long_ref, 16, 1, h->picture_structure);
 +            av_assert0(len <= 32);
  
              if (len < h->ref_count[list])
                  memset(&h->default_ref_list[list][len], 0, sizeof(H264Picture) * (h->ref_count[list] - len));
          len += build_def_list(h->default_ref_list[0] + len,
                                FF_ARRAY_ELEMS(h->default_ref_list[0]) - len,
                                h-> long_ref, 16, 1, h->picture_structure);
 +        av_assert0(len <= 32);
  
          if (len < h->ref_count[0])
              memset(&h->default_ref_list[0][len], 0, sizeof(H264Picture) * (h->ref_count[0] - len));
@@@ -326,19 -322,13 +327,19 @@@ int ff_h264_decode_ref_pic_list_reorder
      }
      for (list = 0; list < h->list_count; list++) {
          for (index = 0; index < h->ref_count[list]; index++) {
 -            if (!h->ref_list[list][index].f.buf[0]) {
 -                av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n");
 -                if (h->default_ref_list[list][0].f.buf[0])
 +            if (   !h->ref_list[list][index].f.buf[0]
 +                || (!FIELD_PICTURE(h) && (h->ref_list[list][index].reference&3) != 3)) {
 +                int i;
 +                av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref_list[list][0].poc);
 +                for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
 +                    h->last_pocs[i] = INT_MIN;
 +                if (h->default_ref_list[list][0].f.buf[0]
 +                    && !(!FIELD_PICTURE(h) && (h->default_ref_list[list][0].reference&3) != 3))
                      COPY_PICTURE(&h->ref_list[list][index], &h->default_ref_list[list][0]);
                  else
                      return -1;
              }
 +            av_assert0(av_buffer_get_ref_count(h->ref_list[list][index].f.buf[0]) > 0);
          }
      }
  
  void ff_h264_fill_mbaff_ref_list(H264Context *h)
  {
      int list, i, j;
 -    for (list = 0; list < 2; list++) { //FIXME try list_count
 +    for (list = 0; list < h->list_count; list++) {
          for (i = 0; i < h->ref_count[list]; i++) {
              H264Picture *frame = &h->ref_list[list][i];
              H264Picture *field = &h->ref_list[list][16 + 2 * i];
@@@ -495,9 -485,6 +496,9 @@@ void ff_h264_remove_all_refs(H264Contex
          h->short_ref[i] = NULL;
      }
      h->short_ref_count = 0;
 +
 +    memset(h->default_ref_list, 0, sizeof(h->default_ref_list));
 +    memset(h->ref_list, 0, sizeof(h->ref_list));
  }
  
  /**
@@@ -539,11 -526,8 +540,11 @@@ static int check_opcodes(MMCO *mmco1, M
      int i;
  
      for (i = 0; i < n_mmcos; i++) {
 -        if (mmco1[i].opcode != mmco2[i].opcode)
 +        if (mmco1[i].opcode != mmco2[i].opcode) {
 +            av_log(NULL, AV_LOG_ERROR, "MMCO opcode [%d, %d] at %d mismatches between slices\n",
 +                   mmco1[i].opcode, mmco2[i].opcode, i);
              return -1;
 +        }
      }
  
      return 0;
@@@ -554,8 -538,10 +555,8 @@@ int ff_generate_sliding_window_mmcos(H2
      MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
      int mmco_index = 0, i = 0;
  
 -    assert(h->long_ref_count + h->short_ref_count <= h->sps.ref_frame_count);
 -
      if (h->short_ref_count &&
 -        h->long_ref_count + h->short_ref_count == h->sps.ref_frame_count &&
 +        h->long_ref_count + h->short_ref_count >= h->sps.ref_frame_count &&
          !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
          mmco[0].opcode        = MMCO_SHORT2UNUSED;
          mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
                 (mmco_index != h->mmco_index ||
                  (i = check_opcodes(h->mmco, mmco_temp, mmco_index)))) {
          av_log(h->avctx, AV_LOG_ERROR,
 -               "Inconsistent MMCO state between slices [%d, %d, %d]\n",
 -               mmco_index, h->mmco_index, i);
 +               "Inconsistent MMCO state between slices [%d, %d]\n",
 +               mmco_index, h->mmco_index);
          return AVERROR_INVALIDDATA;
      }
      return 0;
  int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count)
  {
      int i, av_uninit(j);
 +    int pps_count;
      int current_ref_assigned = 0, err = 0;
      H264Picture *av_uninit(pic);
  
                  if (mmco[i].opcode != MMCO_SHORT2LONG ||
                      !h->long_ref[mmco[i].long_arg]    ||
                      h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
 -                    av_log(h->avctx, AV_LOG_ERROR, "mmco: unref short failure\n");
 +                    av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
                      err = AVERROR_INVALIDDATA;
                  }
                  continue;
                       * Report the problem and keep the pair where it is,
                       * and mark this field valid.
                       */
 -            if (h->short_ref[0] == h->cur_pic_ptr)
 +            if (h->short_ref[0] == h->cur_pic_ptr) {
 +                av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
                  remove_short_at_index(h, 0);
 +            }
  
              if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
 +                if (h->cur_pic_ptr->long_ref) {
 +                    for(j=0; j<16; j++) {
 +                        if(h->long_ref[j] == h->cur_pic_ptr) {
 +                            remove_long(h, j, 0);
 +                            av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
 +                        }
 +                    }
 +                }
 +                av_assert0(!h->cur_pic_ptr->long_ref);
                  remove_long(h, mmco[i].long_arg, 0);
  
                  h->long_ref[mmco[i].long_arg]           = h->cur_pic_ptr;
              h->frame_num  = h->cur_pic_ptr->frame_num = 0;
              h->mmco_reset = 1;
              h->cur_pic_ptr->mmco_reset = 1;
 +            for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
 +                h->last_pocs[j] = INT_MIN;
              break;
          default: assert(0);
          }
          }
      }
  
 -    if (h->long_ref_count + h->short_ref_count -
 -        (h->short_ref[0] == h->cur_pic_ptr) > h->sps.ref_frame_count) {
 +    if (h->long_ref_count + h->short_ref_count > FFMAX(h->sps.ref_frame_count, 1)) {
  
          /* We have too many reference frames, probably due to corrupted
           * stream. Need to discard one frame. Prevents overrun of the
          }
      }
  
 +    for (i = 0; i<h->short_ref_count; i++) {
 +        pic = h->short_ref[i];
 +        if (pic->invalid_gap) {
 +            int d = (h->cur_pic_ptr->frame_num - pic->frame_num) & ((1 << h->sps.log2_max_frame_num)-1);
 +            if (d > h->sps.ref_frame_count)
 +                remove_short(h, pic->frame_num, 0);
 +        }
 +    }
 +
      print_short_term(h);
      print_long_term(h);
 +
 +    pps_count = 0;
 +    for (i = 0; i < FF_ARRAY_ELEMS(h->pps_buffers); i++)
 +        pps_count += !!h->pps_buffers[i];
 +
 +    if (   err >= 0
 +        && h->long_ref_count==0
 +        && (h->short_ref_count<=2 || h->pps.ref_count[0] <= 1 && h->pps.ref_count[1] <= 1 && pps_count == 1)
 +        && h->pps.ref_count[0]<=2 + (h->picture_structure != PICT_FRAME)
 +        && h->cur_pic_ptr->f.pict_type == AV_PICTURE_TYPE_I){
 +        h->cur_pic_ptr->recovered |= 1;
 +        if(!h->avctx->has_b_frames)
 +            h->frame_recovered |= FRAME_RECOVERED_SEI;
 +    }
 +
      return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
  }
  
@@@ -786,7 -735,7 +787,7 @@@ int ff_h264_decode_ref_pic_marking(H264
                                     int first_slice)
  {
      int i, ret;
 -    MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp;
 +    MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = mmco_temp;
      int mmco_index = 0;
  
      if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields
      }
  
      if (first_slice && mmco_index != -1) {
 +        memcpy(h->mmco, mmco_temp, sizeof(h->mmco));
          h->mmco_index = mmco_index;
      } else if (!first_slice && mmco_index >= 0 &&
                 (mmco_index != h->mmco_index ||
diff --combined libavcodec/ituh263dec.c
@@@ -5,20 -5,20 +5,20 @@@
   * Copyright (c) 2001 Juan J. Sierralta P
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -27,7 -27,6 +27,7 @@@
   * h263 decoder.
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
  #include <limits.h>
  
  #include "libavutil/attributes.h"
@@@ -37,6 -36,7 +37,7 @@@
  #include "mpegvideo.h"
  #include "h263.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "unary.h"
  #include "flv.h"
  #include "mpeg4video.h"
@@@ -101,9 -101,11 +102,9 @@@ static VLC cbpc_b_vlc
  /* XXX: find a better solution to handle static init */
  av_cold void ff_h263_decode_init_vlc(void)
  {
 -    static int done = 0;
 +    static volatile int done = 0;
  
      if (!done) {
 -        done = 1;
 -
          INIT_VLC_STATIC(&ff_h263_intra_MCBPC_vlc, INTRA_MCBPC_VLC_BITS, 9,
                   ff_h263_intra_MCBPC_bits, 1, 1,
                   ff_h263_intra_MCBPC_code, 1, 1, 72);
          INIT_VLC_STATIC(&cbpc_b_vlc, CBPC_B_VLC_BITS, 4,
                   &ff_cbpc_b_tab[0][1], 2, 1,
                   &ff_cbpc_b_tab[0][0], 2, 1, 8);
 +        done = 1;
      }
  }
  
@@@ -200,6 -201,27 +201,6 @@@ static int h263_decode_gob_header(MpegE
  }
  
  /**
 - * Find the next resync_marker.
 - * @param p pointer to buffer to scan
 - * @param end pointer to the end of the buffer
 - * @return pointer to the next resync_marker, or end if none was found
 - */
 -const uint8_t *ff_h263_find_resync_marker(const uint8_t *restrict p, const uint8_t * restrict end)
 -{
 -    assert(p < end);
 -
 -    end-=2;
 -    p++;
 -    for(;p<end; p+=2){
 -        if(!*p){
 -            if     (!p[-1] && p[1]) return p - 1;
 -            else if(!p[ 1] && p[2]) return p;
 -        }
 -    }
 -    return end+2;
 -}
 -
 -/**
   * Decode the group of blocks / video packet header.
   * @return bit position of the resync_marker, or <0 if none was found
   */
@@@ -323,7 -345,7 +324,7 @@@ static void preview_obmc(MpegEncContex
          s->block_index[i]+= 1;
      s->mb_x++;
  
 -    assert(s->pict_type == AV_PICTURE_TYPE_P);
 +    av_assert2(s->pict_type == AV_PICTURE_TYPE_P);
  
      do{
          if (get_bits1(&s->gb)) {
@@@ -460,7 -482,7 +461,7 @@@ static int h263_decode_block(MpegEncCon
              level = get_bits(&s->gb, 8);
              if((level&0x7F) == 0){
                  av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
 -                if(s->err_recognition & AV_EF_BITSTREAM)
 +                if(s->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))
                      return -1;
              }
              if (level == 255)
@@@ -541,13 -563,11 +542,13 @@@ static int h263_skip_b_part(MpegEncCont
  {
      LOCAL_ALIGNED_16(int16_t, dblock, [64]);
      int i, mbi;
 +    int bli[6];
  
      /* we have to set s->mb_intra to zero to decode B-part of PB-frame correctly
       * but real value should be restored in order to be used later (in OBMC condition)
       */
      mbi = s->mb_intra;
 +    memcpy(bli, s->block_last_index, sizeof(bli));
      s->mb_intra = 0;
      for (i = 0; i < 6; i++) {
          if (h263_decode_block(s, dblock, i, cbp&32) < 0)
          cbp+=cbp;
      }
      s->mb_intra = mbi;
 +    memcpy(s->block_last_index, bli, sizeof(bli));
      return 0;
  }
  
@@@ -585,7 -604,7 +586,7 @@@ int ff_h263_decode_mb(MpegEncContext *s
      const int xy= s->mb_x + s->mb_y * s->mb_stride;
      int cbpb = 0, pb_mv_count = 0;
  
 -    assert(!s->h263_pred);
 +    av_assert2(!s->h263_pred);
  
      if (s->pict_type == AV_PICTURE_TYPE_P) {
          do{
          }else
              cbp=0;
  
 -        assert(!s->mb_intra);
 +        av_assert2(!s->mb_intra);
  
          if(IS_QUANT(mb_type)){
              h263_decode_dquant(s);
          }
  
          if(IS_DIRECT(mb_type)){
 -            if (!s->pp_time)
 -                return AVERROR_INVALIDDATA;
              s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
              mb_type |= ff_mpeg4_set_direct_mv(s, 0, 0);
          }else{
@@@ -850,10 -871,6 +851,10 @@@ int ff_h263_decode_picture_header(MpegE
  
      align_get_bits(&s->gb);
  
 +    if (show_bits(&s->gb, 2) == 2 && s->avctx->frame_number == 0) {
 +         av_log(s->avctx, AV_LOG_WARNING, "Header looks like RTP instead of H.263\n");
 +    }
 +
      startcode= get_bits(&s->gb, 22-8);
  
      for(i= get_bits_left(&s->gb); i>24; i-=8) {
              s->h263_aic = get_bits1(&s->gb); /* Advanced Intra Coding (AIC) */
              s->loop_filter= get_bits1(&s->gb);
              s->unrestricted_mv = s->umvplus || s->obmc || s->loop_filter;
 +            if(s->avctx->lowres)
 +                s->loop_filter = 0;
  
              s->h263_slice_structured= get_bits1(&s->gb);
              if (get_bits1(&s->gb) != 0) {
                  height = ff_h263_format[format][1];
                  s->avctx->sample_aspect_ratio= (AVRational){12,11};
              }
 +            s->avctx->sample_aspect_ratio.den <<= s->ehc_mode;
              if ((width == 0) || (height == 0))
                  return -1;
              s->width = width;
          s->qscale = get_bits(&s->gb, 5);
      }
  
 +    if (s->width == 0 || s->height == 0) {
 +        av_log(s->avctx, AV_LOG_ERROR, "dimensions 0\n");
 +        return -1;
 +    }
      s->mb_width = (s->width  + 15) / 16;
      s->mb_height = (s->height  + 15) / 16;
      s->mb_num = s->mb_width * s->mb_height;
      }
  
      /* PEI */
 -    while (get_bits1(&s->gb) != 0) {
 -        skip_bits(&s->gb, 8);
 -    }
 +    if (skip_1stop_8data_bits(&s->gb) < 0)
 +        return AVERROR_INVALIDDATA;
  
      if(s->h263_slice_structured){
          if (get_bits1(&s->gb) != 1) {
      }
  
          ff_h263_show_pict_info(s);
 -    if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO")){
 +    if (s->pict_type == AV_PICTURE_TYPE_I && s->codec_tag == AV_RL32("ZYGO") && get_bits_left(&s->gb) >= 85 + 13*3*16 + 50){
          int i,j;
          for(i=0; i<85; i++) av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
          av_log(s->avctx, AV_LOG_DEBUG, "\n");
diff --combined libavcodec/ituh263enc.c
@@@ -5,20 -5,20 +5,20 @@@
   * Copyright (c) 2001 Juan J. Sierralta P
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -34,6 -34,7 +34,7 @@@
  #include "mpegvideo.h"
  #include "h263.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "unary.h"
  #include "flv.h"
  #include "mpeg4video.h"
@@@ -225,7 -226,7 +226,7 @@@ void ff_h263_encode_picture_header(Mpeg
      if(s->h263_slice_structured){
          put_bits(&s->pb, 1, 1);
  
 -        assert(s->mb_x == 0 && s->mb_y == 0);
 +        av_assert1(s->mb_x == 0 && s->mb_y == 0);
          ff_h263_encode_mba(s);
  
          put_bits(&s->pb, 1, 1);
@@@ -267,7 -268,7 +268,7 @@@ void ff_h263_encode_gob_header(MpegEncC
  }
  
  /**
 - * modify qscale so that encoding is acually possible in h263 (limit difference to -2..2)
 + * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
   */
  void ff_clean_h263_qscales(MpegEncContext *s){
      int i;
@@@ -392,7 -393,7 +393,7 @@@ static void h263_encode_block(MpegEncCo
                  put_bits(&s->pb, 1, last);
                  put_bits(&s->pb, 6, run);
  
 -                assert(slevel != 0);
 +                av_assert2(slevel != 0);
  
                  if(level < 128)
                      put_sbits(&s->pb, 8, slevel);
@@@ -545,7 -546,7 +546,7 @@@ void ff_h263_encode_mb(MpegEncContext 
              s->mv_bits+= get_bits_diff(s);
          }
      } else {
 -        assert(s->mb_intra);
 +        av_assert2(s->mb_intra);
  
          cbp = 0;
          if (s->h263_aic) {
@@@ -726,8 -727,8 +727,8 @@@ static av_cold void init_uni_h263_rl_ta
  {
      int slevel, run, last;
  
 -    assert(MAX_LEVEL >= 64);
 -    assert(MAX_RUN   >= 63);
 +    av_assert0(MAX_LEVEL >= 64);
 +    av_assert0(MAX_RUN   >= 63);
  
      for(slevel=-64; slevel<64; slevel++){
          if(slevel==0) continue;
diff --combined libavcodec/motion_est.c
@@@ -5,20 -5,20 +5,20 @@@
   *
   * new motion estimation (X1/EPZS) by Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -33,6 -33,7 +33,7 @@@
  
  #include "avcodec.h"
  #include "mathops.h"
+ #include "mpegutils.h"
  #include "mpegvideo.h"
  
  #undef NDEBUG
@@@ -112,7 -113,7 +113,7 @@@ static av_always_inline int cmp_direct_
      uint8_t * const * const src= c->src[src_index];
      int d;
      //FIXME check chroma 4mv, (no crashes ...)
 -        assert(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1));
 +        av_assert2(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1));
          if(x >= c->xmin && hx <= c->xmax<<(qpel+1) && y >= c->ymin && hy <= c->ymax<<(qpel+1)){
              const int time_pp= s->pp_time;
              const int time_pb= s->pb_time;
                      c->qpel_avg[1][bxy](c->temp     + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride     + 8*stride, stride);
                      c->qpel_avg[1][bxy](c->temp + 8 + 8*stride, ref[8] + (bx>>2) + (by>>2)*stride + 8 + 8*stride, stride);
                  }else{
 -                    assert((fx>>1) + 16*s->mb_x >= -16);
 -                    assert((fy>>1) + 16*s->mb_y >= -16);
 -                    assert((fx>>1) + 16*s->mb_x <= s->width);
 -                    assert((fy>>1) + 16*s->mb_y <= s->height);
 -                    assert((bx>>1) + 16*s->mb_x >= -16);
 -                    assert((by>>1) + 16*s->mb_y >= -16);
 -                    assert((bx>>1) + 16*s->mb_x <= s->width);
 -                    assert((by>>1) + 16*s->mb_y <= s->height);
 +                    av_assert2((fx>>1) + 16*s->mb_x >= -16);
 +                    av_assert2((fy>>1) + 16*s->mb_y >= -16);
 +                    av_assert2((fx>>1) + 16*s->mb_x <= s->width);
 +                    av_assert2((fy>>1) + 16*s->mb_y <= s->height);
 +                    av_assert2((bx>>1) + 16*s->mb_x >= -16);
 +                    av_assert2((by>>1) + 16*s->mb_y >= -16);
 +                    av_assert2((bx>>1) + 16*s->mb_x <= s->width);
 +                    av_assert2((by>>1) + 16*s->mb_y <= s->height);
  
                      c->hpel_put[0][fxy](c->temp, ref[0] + (fx>>1) + (fy>>1)*stride, stride, 16);
                      c->hpel_avg[0][bxy](c->temp, ref[8] + (bx>>1) + (by>>1)*stride, stride, 16);
@@@ -297,12 -298,13 +298,12 @@@ int ff_init_me(MpegEncContext *s)
      int cache_size= FFMIN(ME_MAP_SIZE>>ME_MAP_SHIFT, 1<<ME_MAP_SHIFT);
      int dia_size= FFMAX(FFABS(s->avctx->dia_size)&255, FFABS(s->avctx->pre_dia_size)&255);
  
 -    if(FFMIN(s->avctx->dia_size, s->avctx->pre_dia_size) < -ME_MAP_SIZE){
 +    if(FFMIN(s->avctx->dia_size, s->avctx->pre_dia_size) < -FFMIN(ME_MAP_SIZE, MAX_SAB_SIZE)){
          av_log(s->avctx, AV_LOG_ERROR, "ME_MAP size is too small for SAB diamond\n");
          return -1;
      }
 -    if (s->me_method != ME_ZERO &&
 -        s->me_method != ME_EPZS &&
 -        s->me_method != ME_X1) {
 +    //special case of snow is needed because snow uses its own iterative ME code
 +    if(s->me_method!=ME_ZERO && s->me_method!=ME_EPZS && s->me_method!=ME_X1 && s->avctx->codec_id != AV_CODEC_ID_SNOW){
          av_log(s->avctx, AV_LOG_ERROR, "me_method is only allowed to be set to zero and epzs; for hex,umh,full and others see dia_size\n");
          return -1;
      }
      /* 8x8 fullpel search would need a 4x4 chroma compare, which we do
       * not have yet, and even if we had, the motion estimation code
       * does not expect it. */
 -    if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
 -        s->dsp.me_cmp[2]= zero_cmp;
 -    }
 -    if((c->avctx->me_sub_cmp&FF_CMP_CHROMA) && !s->dsp.me_sub_cmp[2]){
 -        s->dsp.me_sub_cmp[2]= zero_cmp;
 +    if(s->codec_id != AV_CODEC_ID_SNOW){
 +        if((c->avctx->me_cmp&FF_CMP_CHROMA)/* && !s->dsp.me_cmp[2]*/){
 +            s->dsp.me_cmp[2]= zero_cmp;
 +        }
 +        if((c->avctx->me_sub_cmp&FF_CMP_CHROMA) && !s->dsp.me_sub_cmp[2]){
 +            s->dsp.me_sub_cmp[2]= zero_cmp;
 +        }
 +        c->hpel_put[2][0]= c->hpel_put[2][1]=
 +        c->hpel_put[2][2]= c->hpel_put[2][3]= zero_hpel;
      }
 -    c->hpel_put[2][0]= c->hpel_put[2][1]=
 -    c->hpel_put[2][2]= c->hpel_put[2][3]= zero_hpel;
  
      if(s->codec_id == AV_CODEC_ID_H261){
          c->sub_motion_search= no_sub_motion_search;
@@@ -390,9 -390,10 +391,9 @@@ static int sad_hpel_motion_search(MpegE
      int mx, my, dminh;
      uint8_t *pix, *ptr;
      int stride= c->stride;
 -    const int flags= c->sub_flags;
      LOAD_COMMON
  
 -    assert(flags == 0);
 +    av_assert2(c->sub_flags == 0);
  
      if(c->skip){
          *mx_ptr = 0;
@@@ -516,7 -517,6 +517,7 @@@ static inline void get_limits(MpegEncCo
  {
      MotionEstContext * const c= &s->me;
      int range= c->avctx->me_range >> (1 + !!(c->flags&FLAG_QPEL));
 +    int max_range = MAX_MV >> (1 + !!(c->flags&FLAG_QPEL));
  /*
      if(c->avctx->me_range) c->range= c->avctx->me_range >> 1;
      else                   c->range= 16;
      if (s->unrestricted_mv) {
          c->xmin = - x - 16;
          c->ymin = - y - 16;
 -        c->xmax = - x + s->mb_width *16;
 -        c->ymax = - y + s->mb_height*16;
 +        c->xmax = - x + s->width;
 +        c->ymax = - y + s->height;
      } else if (s->out_format == FMT_H261){
          // Search range of H261 is different from other codec standards
          c->xmin = (x > 15) ? - 15 : 0;
          c->xmax = - x + s->mb_width *16 - 16;
          c->ymax = - y + s->mb_height*16 - 16;
      }
 +    if(!range || range > max_range)
 +        range = max_range;
      if(range){
          c->xmin = FFMAX(c->xmin,-range);
          c->xmax = FFMIN(c->xmax, range);
@@@ -566,11 -564,10 +567,11 @@@ static inline int h263_mv4_search(MpegE
      const int h=8;
      int block;
      int P[10][2];
 -    int dmin_sum=0, mx4_sum=0, my4_sum=0;
 +    int dmin_sum=0, mx4_sum=0, my4_sum=0, i;
      int same=1;
      const int stride= c->stride;
      uint8_t *mv_penalty= c->current_mv_penalty;
 +    int saftey_cliping= s->unrestricted_mv && (s->width&15) && (s->height&15);
  
      init_mv4_ref(c);
  
          const int mot_stride = s->b8_stride;
          const int mot_xy = s->block_index[block];
  
 +        if(saftey_cliping){
 +            c->xmax = - 16*s->mb_x + s->width  - 8*(block &1);
 +            c->ymax = - 16*s->mb_y + s->height - 8*(block>>1);
 +        }
 +
          P_LEFT[0] = s->current_picture.motion_val[0][mot_xy - 1][0];
          P_LEFT[1] = s->current_picture.motion_val[0][mot_xy - 1][1];
  
          }
          P_MV1[0]= mx;
          P_MV1[1]= my;
 +        if(saftey_cliping)
 +            for(i=0; i<10; i++){
 +                if(P[i][0] > (c->xmax<<shift)) P[i][0]= (c->xmax<<shift);
 +                if(P[i][1] > (c->ymax<<shift)) P[i][1]= (c->ymax<<shift);
 +            }
  
          dmin4 = epzs_motion_search4(s, &mx4, &my4, P, block, block, s->p_mv_table, (1<<16)>>shift);
  
@@@ -750,8 -737,8 +751,8 @@@ static int interlaced_search(MpegEncCon
              int16_t (*mv_table)[2]= mv_tables[block][field_select];
  
              if(user_field_select){
 -                assert(field_select==0 || field_select==1);
 -                assert(field_select_tables[block][xy]==0 || field_select_tables[block][xy]==1);
 +                av_assert1(field_select==0 || field_select==1);
 +                av_assert1(field_select_tables[block][xy]==0 || field_select_tables[block][xy]==1);
                  if(field_select_tables[block][xy] != field_select)
                      continue;
              }
@@@ -848,10 -835,6 +849,10 @@@ static inline int get_penalty_factor(in
          return lambda>>FF_LAMBDA_SHIFT;
      case FF_CMP_DCT:
          return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
 +    case FF_CMP_W53:
 +        return (4*lambda)>>(FF_LAMBDA_SHIFT);
 +    case FF_CMP_W97:
 +        return (2*lambda)>>(FF_LAMBDA_SHIFT);
      case FF_CMP_SATD:
      case FF_CMP_DCT264:
          return (2*lambda)>>FF_LAMBDA_SHIFT;
@@@ -880,9 -863,9 +881,9 @@@ void ff_estimate_p_frame_motion(MpegEnc
  
      init_ref(c, s->new_picture.f.data, s->last_picture.f.data, NULL, 16*mb_x, 16*mb_y, 0);
  
 -    assert(s->quarter_sample==0 || s->quarter_sample==1);
 -    assert(s->linesize == c->stride);
 -    assert(s->uvlinesize == c->uvstride);
 +    av_assert0(s->quarter_sample==0 || s->quarter_sample==1);
 +    av_assert0(s->linesize == c->stride);
 +    av_assert0(s->uvlinesize == c->uvstride);
  
      c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
      c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
@@@ -1079,7 -1062,7 +1080,7 @@@ int ff_pre_estimate_p_frame_motion(Mpeg
      const int xy= mb_x + mb_y*s->mb_stride;
      init_ref(c, s->new_picture.f.data, s->last_picture.f.data, NULL, 16*mb_x, 16*mb_y, 0);
  
 -    assert(s->quarter_sample==0 || s->quarter_sample==1);
 +    av_assert0(s->quarter_sample==0 || s->quarter_sample==1);
  
      c->pre_penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_pre_cmp);
      c->current_mv_penalty= c->mv_penalty[s->f_code] + MAX_MV;
@@@ -1457,7 -1440,7 +1458,7 @@@ static inline int direct_search(MpegEnc
          if(s->mv_type == MV_TYPE_16X16) break;
      }
  
 -    assert(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
 +    av_assert2(xmax <= 15 && ymax <= 15 && xmin >= -16 && ymin >= -16);
  
      if(xmax < 0 || xmin >0 || ymax < 0 || ymin > 0){
          s->b_direct_mv_table[mot_xy][0]= 0;
@@@ -1673,12 -1656,12 +1674,12 @@@ void ff_fix_long_p_mvs(MpegEncContext 
      MotionEstContext * const c= &s->me;
      const int f_code= s->f_code;
      int y, range;
 -    assert(s->pict_type==AV_PICTURE_TYPE_P);
 +    av_assert0(s->pict_type==AV_PICTURE_TYPE_P);
  
      range = (((s->out_format == FMT_MPEG1 || s->msmpeg4_version) ? 8 : 16) << f_code);
  
 -    assert(range <= 16 || !s->msmpeg4_version);
 -    assert(range <=256 || !(s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL));
 +    av_assert0(range <= 16 || !s->msmpeg4_version);
 +    av_assert0(range <=256 || !(s->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL));
  
      if(c->avctx->me_range && range > c->avctx->me_range) range= c->avctx->me_range;
  
diff --combined libavcodec/mpeg12dec.c
@@@ -1,22 -1,22 +1,22 @@@
  /*
   * MPEG-1/2 decoder
   * Copyright (c) 2000, 2001 Fabrice Bellard
 - * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 + * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -25,7 -25,6 +25,7 @@@
   * MPEG-1/2 decoder
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
  #include "libavutil/attributes.h"
  #include "libavutil/internal.h"
  #include "libavutil/stereo3d.h"
  #include "internal.h"
  #include "mpeg12.h"
  #include "mpeg12data.h"
+ #include "mpegutils.h"
  #include "mpegvideo.h"
  #include "thread.h"
  #include "version.h"
 +#include "vdpau_internal.h"
  #include "xvmc_internal.h"
  
  typedef struct Mpeg1Context {
@@@ -57,7 -56,7 +58,7 @@@
      int save_width, save_height, save_progressive_seq;
      AVRational frame_rate_ext;  /* MPEG-2 specific framerate modificator */
      int sync;                   /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
 -    int closed_gop;             /* GOP is closed */
 +    int tmpgexs;
      int first_slice;
      int extradata_decoded;
  } Mpeg1Context;
@@@ -154,16 -153,15 +155,16 @@@ static inline int mpeg1_decode_block_in
      i = 0;
      {
          OPEN_READER(re, &s->gb);
 +        UPDATE_CACHE(re, &s->gb);
 +        if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
 +            goto end;
 +
          /* now quantify & encode AC coefficients */
          for (;;) {
 -            UPDATE_CACHE(re, &s->gb);
              GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
                         TEX_VLC_BITS, 2, 0);
  
 -            if (level == 127) {
 -                break;
 -            } else if (level != 0) {
 +            if (level != 0) {
                  i += run;
                  check_scantable_index(s, i);
                  j = scantable[i];
                  level = (level - 1) | 1;
                  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
                          SHOW_SBITS(re, &s->gb, 1);
 -                LAST_SKIP_BITS(re, &s->gb, 1);
 +                SKIP_BITS(re, &s->gb, 1);
              } else {
                  /* escape */
                  run = SHOW_UBITS(re, &s->gb, 6) + 1;
                  SKIP_BITS(re, &s->gb, 8);
                  if (level == -128) {
                      level = SHOW_UBITS(re, &s->gb, 8) - 256;
 -                    LAST_SKIP_BITS(re, &s->gb, 8);
 +                    SKIP_BITS(re, &s->gb, 8);
                  } else if (level == 0) {
                      level = SHOW_UBITS(re, &s->gb, 8);
 -                    LAST_SKIP_BITS(re, &s->gb, 8);
 +                    SKIP_BITS(re, &s->gb, 8);
                  }
                  i += run;
                  check_scantable_index(s, i);
              }
  
              block[j] = level;
 +            if (((int32_t)GET_CACHE(re, &s->gb)) <= (int32_t)0xBFFFFFFF)
 +               break;
 +
 +            UPDATE_CACHE(re, &s->gb);
          }
 +end:
 +        LAST_SKIP_BITS(re, &s->gb, 2);
          CLOSE_READER(re, &s->gb);
      }
      s->block_last_index[n] = i;
@@@ -299,11 -291,6 +300,11 @@@ end
      return 0;
  }
  
 +/**
 + * Note: this function can read out of range and crash for corrupt streams.
 + * Changing this would eat up any speed benefits it has.
 + * Do not use "fast" flag if you need the code to be robust.
 + */
  static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
                                                  int16_t *block, int n)
  {
@@@ -466,11 -453,6 +467,11 @@@ end
      return 0;
  }
  
 +/**
 + * Note: this function can read out of range and crash for corrupt streams.
 + * Changing this would eat up any speed benefits it has.
 + * Do not use "fast" flag if you need the code to be robust.
 + */
  static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
                                                      int16_t *block, int n)
  {
  
          if (level != 0) {
              i += run;
 -            check_scantable_index(s, i);
              j = scantable[i];
              level = ((level * 2 + 1) * qscale) >> 1;
              level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
              SKIP_BITS(re, &s->gb, 12);
  
              i += run;
 -            check_scantable_index(s, i);
              j = scantable[i];
              if (level < 0) {
                  level = ((-level * 2 + 1) * qscale) >> 1;
          }
  
          block[j] = level;
 -        if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
 +        if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
              break;
 +
          UPDATE_CACHE(re, &s->gb);
      }
  end:
@@@ -617,11 -600,6 +618,11 @@@ static inline int mpeg2_decode_block_in
      return 0;
  }
  
 +/**
 + * Note: this function can read out of range and crash for corrupt streams.
 + * Changing this would eat up any speed benefits it has.
 + * Do not use "fast" flag if you need the code to be robust.
 + */
  static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
                                                  int16_t *block, int n)
  {
              GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
                         TEX_VLC_BITS, 2, 0);
  
 -            if (level == 127) {
 +            if (level >= 64 || i > 63) {
                  break;
              } else if (level != 0) {
                  i += run;
 -                check_scantable_index(s, i);
                  j = scantable[i];
                  level = (level * qscale * quant_matrix[j]) >> 4;
                  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
                  level = SHOW_SBITS(re, &s->gb, 12);
                  SKIP_BITS(re, &s->gb, 12);
                  i += run;
 -                check_scantable_index(s, i);
                  j = scantable[i];
                  if (level < 0) {
                      level = (-level * qscale * quant_matrix[j]) >> 4;
@@@ -716,7 -696,6 +717,7 @@@ static inline int get_qscale(MpegEncCon
          return qscale << 1;
  }
  
 +
  /* motion type (for MPEG-2) */
  #define MT_FIELD 1
  #define MT_FRAME 2
@@@