Merge commit '3176217c60ca7828712985092d9102d331ea4f3d'
authorClément Bœsch <u@pkh.me>
Sun, 12 Jun 2016 11:24:27 +0000 (13:24 +0200)
committerClément Bœsch <u@pkh.me>
Sun, 12 Jun 2016 11:26:52 +0000 (13:26 +0200)
* commit '3176217c60ca7828712985092d9102d331ea4f3d':
  h264: decouple h264_ps from the h264 decoder

Main changes:

- a local GetBitContext is created for the various
  ff_h264_decode_seq_parameter_set() attempts

- just like the old code, remove_sps() is adjusted so it doesn't remove
  the pps.

  Fixes decode with Ticket #631
  http://ffmpeg.org/pipermail/ffmpeg-user/attachments/20111108/dae58f17/attachment.mp4
  but see next point as well.

- ff_h264_update_thread_context() is updated to work even when SPS
  isn't set as it breaks current skip_frame code. This makes sure we
  can still decode the sample from ticket #631 without the need for
  -flags2 +chunks. (Thanks to Michael)

- keep {sps,pps}_ref pointers that stay alive even when the active
  pps/sps get removed from the available lists (patch by michaelni with
  additionnal frees in ff_h264_free_context() from mateo)

- added a check on sps in avpriv_h264_has_num_reorder_frames() to fix
  crashes with mpegts_with_dvbsubs.ts from Ticket #4074
  http://samples.ffmpeg.org/ffmpeg-bugs/trac/ticket4074/mpegts_with_dvbsubs.ts

- in h264_parser.c:h264_parse(), after the ff_h264_decode_extradata() is
  called, the pps and sps from the local parser context are updated with
  the pps and sps from the used h264context. This fixes fate-flv-demux.

- in h264_slice.c, "PPS changed between slices" error is not triggered
  anymore in one condition as it makes fate-h264-xavc-4389 fails with
  THREADS=N (Thanks to Michael)

Merged-by: Clément Bœsch <clement@stupeflix.com>
Merged-by: Michael Niedermayer <michael@niedermayer.cc>
Merged-by: Matthieu Bouron <matthieu.bouron@stupeflix.com>
19 files changed:
1  2 
libavcodec/dxva2_h264.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_mb.c
libavcodec/h264_mb_template.c
libavcodec/h264_mvpred.h
libavcodec/h264_parser.c
libavcodec/h264_ps.c
libavcodec/h264_refs.c
libavcodec/h264_sei.c
libavcodec/h264_slice.c
libavcodec/vaapi_h264.c
libavcodec/vdpau.c
libavcodec/vdpau_h264.c
libavcodec/videotoolbox.c

diff --combined libavcodec/dxva2_h264.c
@@@ -3,25 -3,23 +3,25 @@@
   *
   * 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 "libavutil/avassert.h"
 +
  #include "h264.h"
  #include "h264data.h"
  #include "mpegutils.h"
@@@ -52,6 -50,8 +52,8 @@@ static void fill_picture_parameters(con
                                      DXVA_PicParams_H264 *pp)
  {
      const H264Picture *current_picture = h->cur_pic_ptr;
+     const SPS *sps = h->ps.sps;
+     const PPS *pps = h->ps.pps;
      int i, j;
  
      memset(pp, 0, sizeof(*pp));
  
      pp->wFrameWidthInMbsMinus1        = h->mb_width  - 1;
      pp->wFrameHeightInMbsMinus1       = h->mb_height - 1;
-     pp->num_ref_frames                = h->sps.ref_frame_count;
+     pp->num_ref_frames                = sps->ref_frame_count;
  
      pp->wBitFields                    = ((h->picture_structure != PICT_FRAME) <<  0) |
-                                         ((h->sps.mb_aff &&
+                                         ((sps->mb_aff &&
                                          (h->picture_structure == PICT_FRAME)) <<  1) |
-                                         (h->sps.residual_color_transform_flag <<  2) |
+                                         (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) |
+                                         (sps->chroma_format_idc               <<  4) |
                                          ((h->nal_ref_idc != 0)                <<  6) |
-                                         (h->pps.constrained_intra_pred        <<  7) |
-                                         (h->pps.weighted_pred                 <<  8) |
-                                         (h->pps.weighted_bipred_idc           <<  9) |
+                                         (pps->constrained_intra_pred          <<  7) |
+                                         (pps->weighted_pred                   <<  8) |
+                                         (pps->weighted_bipred_idc             <<  9) |
                                          /* MbsConsecutiveFlag */
                                          (1                                    << 11) |
-                                         (h->sps.frame_mbs_only_flag           << 12) |
-                                         (h->pps.transform_8x8_mode            << 13) |
-                                         ((h->sps.level_idc >= 31)             << 14) |
+                                         (sps->frame_mbs_only_flag             << 12) |
+                                         (pps->transform_8x8_mode              << 13) |
+                                         ((sps->level_idc >= 31)               << 14) |
                                          /* IntraPicFlag (Modified if we detect a non
                                           * intra slice in dxva2_h264_decode_slice) */
                                          (1                                    << 15);
  
-     pp->bit_depth_luma_minus8         = h->sps.bit_depth_luma - 8;
-     pp->bit_depth_chroma_minus8       = h->sps.bit_depth_chroma - 8;
+     pp->bit_depth_luma_minus8         = sps->bit_depth_luma - 8;
+     pp->bit_depth_chroma_minus8       = sps->bit_depth_chroma - 8;
      if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG)
          pp->Reserved16Bits            = 0;
      else if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO)
      if ((h->picture_structure & PICT_BOTTOM_FIELD) &&
          current_picture->field_poc[1] != INT_MAX)
          pp->CurrFieldOrderCnt[1] = current_picture->field_poc[1];
-     pp->pic_init_qs_minus26           = h->pps.init_qs - 26;
-     pp->chroma_qp_index_offset        = h->pps.chroma_qp_index_offset[0];
-     pp->second_chroma_qp_index_offset = h->pps.chroma_qp_index_offset[1];
+     pp->pic_init_qs_minus26           = pps->init_qs - 26;
+     pp->chroma_qp_index_offset        = pps->chroma_qp_index_offset[0];
+     pp->second_chroma_qp_index_offset = pps->chroma_qp_index_offset[1];
      pp->ContinuationFlag              = 1;
-     pp->pic_init_qp_minus26           = h->pps.init_qp - 26;
-     pp->num_ref_idx_l0_active_minus1  = h->pps.ref_count[0] - 1;
-     pp->num_ref_idx_l1_active_minus1  = h->pps.ref_count[1] - 1;
+     pp->pic_init_qp_minus26           = pps->init_qp - 26;
+     pp->num_ref_idx_l0_active_minus1  = pps->ref_count[0] - 1;
+     pp->num_ref_idx_l1_active_minus1  = pps->ref_count[1] - 1;
      pp->Reserved8BitsA                = 0;
      pp->frame_num                     = h->frame_num;
-     pp->log2_max_frame_num_minus4     = h->sps.log2_max_frame_num - 4;
-     pp->pic_order_cnt_type            = h->sps.poc_type;
-     if (h->sps.poc_type == 0)
-         pp->log2_max_pic_order_cnt_lsb_minus4 = h->sps.log2_max_poc_lsb - 4;
-     else if (h->sps.poc_type == 1)
-         pp->delta_pic_order_always_zero_flag = h->sps.delta_pic_order_always_zero_flag;
-     pp->direct_8x8_inference_flag     = h->sps.direct_8x8_inference_flag;
-     pp->entropy_coding_mode_flag      = h->pps.cabac;
-     pp->pic_order_present_flag        = h->pps.pic_order_present;
-     pp->num_slice_groups_minus1       = h->pps.slice_group_count - 1;
-     pp->slice_group_map_type          = h->pps.mb_slice_group_map_type;
-     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->log2_max_frame_num_minus4     = sps->log2_max_frame_num - 4;
+     pp->pic_order_cnt_type            = sps->poc_type;
+     if (sps->poc_type == 0)
+         pp->log2_max_pic_order_cnt_lsb_minus4 = sps->log2_max_poc_lsb - 4;
+     else if (sps->poc_type == 1)
+         pp->delta_pic_order_always_zero_flag = sps->delta_pic_order_always_zero_flag;
+     pp->direct_8x8_inference_flag     = sps->direct_8x8_inference_flag;
+     pp->entropy_coding_mode_flag      = pps->cabac;
+     pp->pic_order_present_flag        = pps->pic_order_present;
+     pp->num_slice_groups_minus1       = pps->slice_group_count - 1;
+     pp->slice_group_map_type          = pps->mb_slice_group_map_type;
+     pp->deblocking_filter_control_present_flag = pps->deblocking_filter_parameters_present;
+     pp->redundant_pic_cnt_present_flag= 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(const AVCodecContext *avctx, AVDXVAContext *ctx, const H264Context *h, DXVA_Qmatrix_H264 *qm)
  {
++    const PPS *pps = h->ps.pps;
      unsigned i, j;
      memset(qm, 0, sizeof(*qm));
      if (DXVA_CONTEXT_WORKAROUND(avctx, ctx) & FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG) {
          for (i = 0; i < 6; i++)
              for (j = 0; j < 16; j++)
-                 qm->bScalingLists4x4[i][j] = h->pps.scaling_matrix4[i][j];
+                 qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][j];
  
          for (i = 0; i < 64; i++) {
-             qm->bScalingLists8x8[0][i] = h->pps.scaling_matrix8[0][i];
-             qm->bScalingLists8x8[1][i] = h->pps.scaling_matrix8[3][i];
+             qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][i];
+             qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][i];
          }
      } else {
          for (i = 0; i < 6; i++)
              for (j = 0; j < 16; j++)
-                 qm->bScalingLists4x4[i][j] = h->pps.scaling_matrix4[i][ff_zigzag_scan[j]];
+                 qm->bScalingLists4x4[i][j] = pps->scaling_matrix4[i][ff_zigzag_scan[j]];
  
          for (i = 0; i < 64; i++) {
-             qm->bScalingLists8x8[0][i] = h->pps.scaling_matrix8[0][ff_zigzag_direct[i]];
-             qm->bScalingLists8x8[1][i] = h->pps.scaling_matrix8[3][ff_zigzag_direct[i]];
+             qm->bScalingLists8x8[0][i] = pps->scaling_matrix8[0][ff_zigzag_direct[i]];
+             qm->bScalingLists8x8[1][i] = pps->scaling_matrix8[3][ff_zigzag_direct[i]];
          }
      }
  }
@@@ -228,7 -228,7 +231,7 @@@ static void fill_slice_long(AVCodecCont
  
      slice->first_mb_in_slice     = (sl->mb_y >> FIELD_OR_MBAFF_PICTURE(h)) * h->mb_width + sl->mb_x;
      slice->NumMbsForSlice        = 0; /* XXX it is set once we have all slices */
 -    slice->BitOffsetToSliceData  = get_bits_count(&sl->gb);
 +    slice->BitOffsetToSliceData  = get_bits_count(&sl->gb) - 8;
      slice->slice_type            = ff_h264_get_slice_type(sl);
      if (sl->slice_type_fixed)
          slice->slice_type += 5;
                  else
                      index = get_refpic_index(pp, ff_dxva2_get_surface_index(avctx, ctx, r->f));
                  fill_picture_entry(&slice->RefPicList[list][i], index,
 -                                   r->reference == PICT_BOTTOM_FIELD);
 +                                   sl->ref_list[list][i].reference == PICT_BOTTOM_FIELD);
                  for (plane = 0; plane < 3; plane++) {
                      int w, o;
                      if (plane == 0 && sl->pwt.luma_weight_flag[list]) {
              }
          }
      }
 -    slice->slice_qs_delta    = 0; /* XXX not implemented by Libav */
 +    slice->slice_qs_delta    = 0; /* XXX not implemented by FFmpeg */
-     slice->slice_qp_delta    = sl->qscale - h->pps.init_qp;
+     slice->slice_qp_delta    = sl->qscale - h->ps.pps->init_qp;
      slice->redundant_pic_cnt = sl->redundant_pic_count;
      if (sl->slice_type == AV_PICTURE_TYPE_B)
          slice->direct_spatial_mv_pred_flag = sl->direct_spatial_mv_pred;
-     slice->cabac_init_idc = h->pps.cabac ? sl->cabac_init_idc : 0;
+     slice->cabac_init_idc = h->ps.pps->cabac ? sl->cabac_init_idc : 0;
      if (sl->deblocking_filter < 2)
          slice->disable_deblocking_filter_idc = 1 - sl->deblocking_filter;
      else
@@@ -304,9 -304,9 +307,9 @@@ static int commit_bitstream_and_slice_b
      const H264Picture *current_picture = h->cur_pic_ptr;
      struct dxva2_picture_context *ctx_pic = current_picture->hwaccel_picture_private;
      DXVA_Slice_H264_Short *slice = NULL;
 -    void     *dxva_data_ptr;
 +    void     *dxva_data_ptr = NULL;
      uint8_t  *dxva_data, *current, *end;
 -    unsigned dxva_size;
 +    unsigned dxva_size = 0;
      void     *slice_data;
      unsigned slice_size;
      unsigned padding;
          dsc11->NumMBsInBuffer       = mb_count;
  
          type = D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
 +
 +        av_assert0((dsc11->DataSize & 127) == 0);
      }
  #endif
  #if CONFIG_DXVA2
          dsc2->NumMBsInBuffer       = mb_count;
  
          type = DXVA2_SliceControlBufferType;
 +
 +        av_assert0((dsc2->DataSize & 127) == 0);
      }
  #endif
  
          slice_data = ctx_pic->slice_long;
          slice_size = ctx_pic->slice_count * sizeof(*ctx_pic->slice_long);
      }
 -    assert((bs->DataSize & 127) == 0);
      return ff_dxva2_commit_buffer(avctx, ctx, sc,
                                    type,
                                    slice_data, slice_size, mb_count);
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
   */
  
@@@ -25,8 -25,6 +25,8 @@@
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
 +
  #include "libavutil/avassert.h"
  #include "libavutil/display.h"
  #include "libavutil/imgutils.h"
  #include "profiles.h"
  #include "rectangle.h"
  #include "thread.h"
 +#include "vdpau_compat.h"
  
 -#include <assert.h>
 +static int h264_decode_end(AVCodecContext *avctx);
  
  const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
  
-     return h ? h->sps.num_reorder_frames : 0;
 +int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
 +{
 +    H264Context *h = avctx->priv_data;
++    return h && h->ps.sps ? h->ps.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)
      sl->mb_y = mb_y;
      sl->mb_xy = mb_x + mb_y * h->mb_stride;
      memset(sl->non_zero_count_cache, 0, sizeof(sl->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 >= sl->ref_count[0])
          ref = 0;
 +    if (!sl->ref_list[0][ref].data[0]) {
 +        av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
 +        ref = 0;
 +    }
 +    if ((sl->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 * sl->mb_xy],
                     2, 2, 2, ref, 1);
      fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
      fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
                     pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
 -    assert(!FRAME_MBAFF(h));
 +    sl->mb_mbaff =
 +    sl->mb_field_decoding_flag = 0;
      ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
  }
  
@@@ -180,11 -162,11 +180,11 @@@ void ff_h264_free_tables(H264Context *h
  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;
  
 -    FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
 -                      row_mb_num * 8 * sizeof(uint8_t), fail)
 +    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
 +                      row_mb_num, 8 * sizeof(uint8_t), fail)
      h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
  
      FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
                        big_mb_num * sizeof(uint16_t), fail)
      FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
                        big_mb_num * sizeof(uint8_t), fail)
 -    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[0],
 -                      16 * row_mb_num * sizeof(uint8_t), fail);
 -    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[1],
 -                      16 * row_mb_num * sizeof(uint8_t), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
 +                      row_mb_num, 16 * sizeof(uint8_t), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
 +                      row_mb_num, 16 * sizeof(uint8_t), fail);
      h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
      h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
  
              h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
          }
  
-     if (!h->dequant4_coeff[0])
-         ff_h264_init_dequant_tables(h);
      return 0;
  
  fail:
@@@ -254,11 -233,7 +251,11 @@@ int ff_h264_slice_context_init(H264Cont
      sl->ref_cache[1][scan8[7]  + 1] =
      sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
  
 +    if (sl != h->slice_ctx) {
 +        memset(er, 0, sizeof(*er));
 +    } else
      if (CONFIG_ERROR_RESILIENCE) {
 +
          /* init ER */
          er->avctx          = h->avctx;
          er->decode_mb      = h264_er_decode_mb;
@@@ -355,23 -330,20 +352,23 @@@ static int decode_extradata_ps_mp4(H264
      return 0;
  }
  
 -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_extradata_ps_mp4(h, p, nalsize);
              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_extradata_ps_mp4(h, p, nalsize);
              if (ret < 0) {
              p += nalsize;
          }
          // 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;
  }
  
  static int h264_init_context(AVCodecContext *avctx, H264Context *h)
      int i;
  
      h->avctx                 = avctx;
-     h->dequant_coeff_pps     = -1;
 +    h->backup_width          = -1;
 +    h->backup_height         = -1;
 +    h->backup_pix_fmt        = AV_PIX_FMT_NONE;
 +    h->current_sps_id        = -1;
 +    h->cur_chroma_format_idc = -1;
  
      h->picture_structure     = PICT_FRAME;
      h->slice_context_count   = 1;
      h->x264_build            = -1;
      h->recovery_frame        = -1;
      h->frame_recovered       = 0;
 +    h->prev_frame_num        = -1;
 +    h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
  
      h->next_outputed_poc = INT_MIN;
      for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
      if (!h->cur_pic.f)
          return AVERROR(ENOMEM);
  
 +    h->last_pic_for_ec.f = av_frame_alloc();
 +    if (!h->last_pic_for_ec.f)
 +        return AVERROR(ENOMEM);
 +
      for (i = 0; i < h->nb_slice_ctx; i++)
          h->slice_ctx[i].h264 = h;
  
@@@ -497,46 -457,36 +493,46 @@@ av_cold int ff_h264_decode_init(AVCodec
      }
  
      if (avctx->codec_id == AV_CODEC_ID_H264) {
 -        if (avctx->ticks_per_frame == 1)
 -            h->avctx->framerate.num *= 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) {
 -           ff_h264_free_context(h);
 -           return ret;
 -       }
 +        ret = ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);
 +        if (ret < 0) {
 +            h264_decode_end(avctx);
 +            return ret;
 +        }
      }
  
-     if (h->sps.bitstream_restriction_flag &&
-         h->avctx->has_b_frames < h->sps.num_reorder_frames) {
-         h->avctx->has_b_frames = h->sps.num_reorder_frames;
+     if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
+         h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {
+         h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
          h->low_delay           = 0;
      }
  
      avctx->internal->allocate_progress = 1;
  
 -    if (h->enable_er) {
 +    ff_h264_flush_change(h);
 +
 +    if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
 +        h->enable_er = 0;
 +
 +    if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
          av_log(avctx, AV_LOG_WARNING,
 -               "Error resilience is enabled. It is unsafe and unsupported and may crash. "
 +               "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
                 "Use it at your own risk\n");
      }
  
      return 0;
  }
  
 +#if HAVE_THREADS
  static int decode_init_thread_copy(AVCodecContext *avctx)
  {
      H264Context *h = avctx->priv_data;
  
      return 0;
  }
 +#endif
  
  /**
   * Run setup operations that must be run after slice header decoding.
   */
  static void decode_postinit(H264Context *h, int setup_finished)
  {
+     const SPS *sps = h->ps.sps;
      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;
  
           * yet, so we assume the worst for now. */
          // if (setup_finished)
          //    ff_thread_finish_setup(h->avctx);
 -        return;
 +        if (cur->field_poc[0] == INT_MAX && cur->field_poc[1] == INT_MAX)
 +            return;
 +        if (h->avctx->hwaccel || h->missing_fields <=1)
 +            return;
      }
  
      cur->f->interlaced_frame = 0;
      /* Prioritize picture timing SEI information over used
       * decoding process if it exists. */
  
-     if (h->sps.pic_struct_present_flag) {
+     if (sps->pic_struct_present_flag) {
          switch (h->sei_pic_struct) {
          case SEI_PIC_STRUCT_FRAME:
              break;
          /* Derive top_field_first from field pocs. */
          cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
      } else {
-         if (h->sps.pic_struct_present_flag) {
 -        if (cur->f->interlaced_frame || sps->pic_struct_present_flag) {
++        if (sps->pic_struct_present_flag) {
              /* Use picture timing SEI information. Even if it is a
               * information of a past frame, better than nothing. */
              if (h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM ||
                  cur->f->top_field_first = 1;
              else
                  cur->f->top_field_first = 0;
 +        } else if (cur->f->interlaced_frame) {
 +            /* Default to top field first when pic_struct_present_flag
 +             * is not set but interlaced frame detected */
 +            cur->f->top_field_first = 1;
          } else {
              /* Most likely progressive */
              cur->f->top_field_first = 0;
          h->content_interpretation_type > 0 &&
          h->content_interpretation_type < 3) {
          AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
 -        if (!stereo)
 -            return;
 -
 +        if (stereo) {
          switch (h->frame_packing_arrangement_type) {
          case 0:
              stereo->type = AV_STEREO3D_CHECKERBOARD;
  
          if (h->content_interpretation_type == 2)
              stereo->flags = AV_STEREO3D_FLAG_INVERT;
 +        }
      }
  
      if (h->sei_display_orientation_present &&
          AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
                                                             AV_FRAME_DATA_DISPLAYMATRIX,
                                                             sizeof(int32_t) * 9);
 -        if (!rotation)
 -            return;
 -
 -        av_display_rotation_set((int32_t *)rotation->data, angle);
 -        av_display_matrix_flip((int32_t *)rotation->data,
 -                               h->sei_hflip, h->sei_vflip);
 +        if (rotation) {
 +            av_display_rotation_set((int32_t *)rotation->data, angle);
 +            av_display_matrix_flip((int32_t *)rotation->data,
 +                                   h->sei_hflip, h->sei_vflip);
 +        }
      }
  
      if (h->sei_reguserdata_afd_present) {
          AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
                                                       sizeof(uint8_t));
 -        if (!sd)
 -            return;
  
 -        *sd->data = h->active_format_description;
 -        h->sei_reguserdata_afd_present = 0;
 +        if (sd) {
 +            *sd->data = h->active_format_description;
 +            h->sei_reguserdata_afd_present = 0;
 +        }
      }
  
      if (h->a53_caption) {
          AVFrameSideData *sd = av_frame_new_side_data(cur->f,
                                                       AV_FRAME_DATA_A53_CC,
                                                       h->a53_caption_size);
 -        if (!sd)
 -            return;
 -
 -        memcpy(sd->data, h->a53_caption, h->a53_caption_size);
 +        if (sd)
 +            memcpy(sd->data, h->a53_caption, h->a53_caption_size);
          av_freep(&h->a53_caption);
          h->a53_caption_size = 0;
 +        h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
      }
  
 +    cur->mmco_reset = h->mmco_reset;
 +    h->mmco_reset = 0;
 +
      // FIXME do something with unavailable reference frames
  
      /* Sort B-frames into display order */
-     if (h->sps.bitstream_restriction_flag ||
+     if (sps->bitstream_restriction_flag ||
 -        h->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
 +        h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
-         h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, h->sps.num_reorder_frames);
+         h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
      }
      h->low_delay = !h->avctx->has_b_frames;
  
-     } else if(h->avctx->has_b_frames < out_of_order && !h->sps.bitstream_restriction_flag){
 +    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 && !sps->bitstream_restriction_flag){
 +        av_log(h->avctx, AV_LOG_INFO, "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);
 -
 -    if (sps->bitstream_restriction_flag &&
 -        h->avctx->has_b_frames >= 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++;
 -    }
 +    out_of_order = out->poc < h->next_outputed_poc;
  
 -    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) {
   */
  static void idr(H264Context *h)
  {
 +    int i;
      ff_h264_remove_all_refs(h);
      h->prev_frame_num        =
 -    h->prev_frame_num_offset =
 -    h->prev_poc_msb          =
 +    h->prev_frame_num_offset = 0;
 +    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 */
  void ff_h264_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->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;
 +    }
 +    ff_h264_unref_picture(h, &h->last_pic_for_ec);
 +
      h->first_field = 0;
      ff_h264_reset_sei(h);
      h->recovery_frame = -1;
      h->frame_recovered = 0;
 +    h->current_slice = 0;
 +    h->mmco_reset = 1;
 +    for (i = 0; i < h->nb_slice_ctx; i++)
 +        h->slice_ctx[i].list_count = 0;
  }
  
  /* forget old pics after a seek */
@@@ -894,15 -859,16 +891,16 @@@ static void flush_dpb(AVCodecContext *a
  
  int ff_init_poc(H264Context *h, int pic_field_poc[2], int *pic_poc)
  {
-     const int max_frame_num = 1 << h->sps.log2_max_frame_num;
+     const SPS *sps = h->ps.sps;
+     const int max_frame_num = 1 << sps->log2_max_frame_num;
      int field_poc[2];
  
      h->frame_num_offset = h->prev_frame_num_offset;
      if (h->frame_num < h->prev_frame_num)
          h->frame_num_offset += max_frame_num;
  
-     if (h->sps.poc_type == 0) {
-         const int max_poc_lsb = 1 << h->sps.log2_max_poc_lsb;
+     if (sps->poc_type == 0) {
+         const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
  
          if (h->poc_lsb < h->prev_poc_lsb &&
              h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb / 2)
          field_poc[1] = h->poc_msb + h->poc_lsb;
          if (h->picture_structure == PICT_FRAME)
              field_poc[1] += h->delta_poc_bottom;
-     } else if (h->sps.poc_type == 1) {
+     } else if (sps->poc_type == 1) {
          int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
          int i;
  
-         if (h->sps.poc_cycle_length != 0)
+         if (sps->poc_cycle_length != 0)
              abs_frame_num = h->frame_num_offset + h->frame_num;
          else
              abs_frame_num = 0;
              abs_frame_num--;
  
          expected_delta_per_poc_cycle = 0;
-         for (i = 0; i < h->sps.poc_cycle_length; i++)
+         for (i = 0; i < sps->poc_cycle_length; i++)
              // FIXME integrate during sps parse
-             expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[i];
+             expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
  
          if (abs_frame_num > 0) {
-             int poc_cycle_cnt          = (abs_frame_num - 1) / h->sps.poc_cycle_length;
-             int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length;
+             int poc_cycle_cnt          = (abs_frame_num - 1) / sps->poc_cycle_length;
+             int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;
  
              expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
              for (i = 0; i <= frame_num_in_poc_cycle; i++)
-                 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[i];
+                 expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];
          } else
              expectedpoc = 0;
  
          if (h->nal_ref_idc == 0)
-             expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic;
+             expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;
  
          field_poc[0] = expectedpoc + h->delta_poc[0];
-         field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field;
+         field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;
  
          if (h->picture_structure == PICT_FRAME)
              field_poc[1] += h->delta_poc[1];
   *
   * @return profile as defined by FF_PROFILE_H264_*
   */
- int ff_h264_get_profile(SPS *sps)
+ int ff_h264_get_profile(const SPS *sps)
  {
      int profile = sps->profile_idc;
  
      return profile;
  }
  
 +
 +#if FF_API_CAP_VDPAU
 +static const uint8_t start_code[] = { 0x00, 0x00, 0x01 };
 +#endif
 +
  static int get_last_needed_nal(H264Context *h)
  {
      int nals_needed = 0;
 +    int first_slice = 0;
      int i;
 +    int ret;
  
      for (i = 0; i < h->pkt.nb_nals; i++) {
          H2645NAL *nal = &h->pkt.nals[i];
          case NAL_DPA:
          case NAL_IDR_SLICE:
          case NAL_SLICE:
 -            init_get_bits(&gb, nal->data + 1, (nal->size - 1) * 8);
 -            if (!get_ue_golomb(&gb))
 +            ret = init_get_bits8(&gb, nal->data + 1, (nal->size - 1));
 +            if (ret < 0)
 +                return ret;
 +            if (!get_ue_golomb_long(&gb) ||  // first_mb_in_slice
 +                !first_slice ||
 +                first_slice != nal->type)
                  nals_needed = i;
 +            if (!first_slice)
 +                first_slice = nal->type;
          }
      }
  
@@@ -1046,13 -999,8 +1044,13 @@@ static int decode_nal_units(H264Contex
      AVCodecContext *const avctx = h->avctx;
      unsigned context_count = 0;
      int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
 +    int idr_cleared=0;
      int i, 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 & AV_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;
 +    }
 +
      ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
                                  h->nal_length_size, avctx->codec_id);
      if (ret < 0) {
          av_log(avctx, AV_LOG_ERROR,
                 "Error splitting the input into NAL units.\n");
 -        return ret;
 +        /* don't consider NAL parsing failure a fatal error when parsing extradata, as the stream may work without it */
 +        return parse_extradata ? buf_size : ret;
      }
  
      if (avctx->active_thread_type & FF_THREAD_FRAME)
          nals_needed = get_last_needed_nal(h);
 +    if (nals_needed < 0)
 +        return nals_needed;
  
      for (i = 0; i < h->pkt.nb_nals; i++) {
          H2645NAL *nal = &h->pkt.nals[i];
              continue;
  
  again:
 -        /* Ignore every NAL unit type except PPS and SPS during extradata
 +        /* 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) &&
 -            (nal->type != NAL_PPS && nal->type != NAL_SPS)) {
 -            if (nal->type < NAL_AUD || nal->type > NAL_AUXILIARY_SLICE)
 -                av_log(avctx, AV_LOG_INFO,
 -                       "Ignoring NAL unit %d during extradata parsing\n",
 +        if (parse_extradata) {
 +            switch (nal->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",
                         nal->type);
 -            nal->type = NAL_FF_IGNORE;
 +                // fall through to next case
 +            case NAL_AUXILIARY_SLICE:
 +                nal->type = NAL_FF_IGNORE;
 +            }
          }
  
          // FIXME these should stop being context-global variables
          err = 0;
          switch (nal->type) {
          case NAL_IDR_SLICE:
 +            if ((nal->data[1] & 0xFC) == 0x98) {
 +                av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
 +                h->next_outputed_poc = INT_MIN;
 +                ret = -1;
 +                goto end;
 +            }
              if (nal->type != NAL_IDR_SLICE) {
                  av_log(h->avctx, AV_LOG_ERROR,
                         "Invalid mix of idr and non-idr slices\n");
                  ret = -1;
                  goto end;
              }
 -            idr(h); // FIXME ensure we don't lose some frames if there is reordering
 +            if(!idr_cleared) {
 +                if (h->current_slice && (avctx->active_thread_type & FF_THREAD_SLICE)) {
 +                    av_log(h, AV_LOG_ERROR, "invalid mixed IDR / non IDR frames cannot be decoded in slice multithreading mode\n");
 +                    ret = AVERROR_INVALIDDATA;
 +                    goto end;
 +                }
 +                idr(h); // FIXME ensure we don't lose some frames if there is reordering
 +            }
 +            idr_cleared = 1;
 +            h->has_recovery_point = 1;
          case NAL_SLICE:
              sl->gb = nal->gb;
 +            if (   nals_needed >= i
 +                || (!(avctx->active_thread_type & FF_THREAD_FRAME) && !context_count))
 +                h->au_pps_id = -1;
  
              if ((err = ff_h264_decode_slice_header(h, sl)))
                  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->ps.sps->log2_max_frame_num) - 1);
 +            if (h->sei_recovery_frame_cnt >= 0) {
 +                if (h->frame_num != h->sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
 +                    h->valid_recovery_point = 1;
 +
 +                if (   h->recovery_frame < 0
-                     || av_mod_uintp2(h->recovery_frame - h->frame_num, h->sps.log2_max_frame_num) > h->sei_recovery_frame_cnt) {
-                     h->recovery_frame = av_mod_uintp2(h->frame_num + h->sei_recovery_frame_cnt, h->sps.log2_max_frame_num);
++                    || av_mod_uintp2(h->recovery_frame - h->frame_num, h->ps.sps->log2_max_frame_num) > h->sei_recovery_frame_cnt) {
++                    h->recovery_frame = av_mod_uintp2(h->frame_num + h->sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
 +
 +                    if (!h->valid_recovery_point)
 +                        h->recovery_frame = h->frame_num;
 +                }
              }
  
 -            h->cur_pic_ptr->f->key_frame |=
 -                (nal->type == NAL_IDR_SLICE) || (h->sei_recovery_frame_cnt >= 0);
 +            h->cur_pic_ptr->f->key_frame |= (nal->type == NAL_IDR_SLICE);
  
 -            if (nal->type == NAL_IDR_SLICE || h->recovery_frame == h->frame_num) {
 +            if (nal->type == NAL_IDR_SLICE ||
 +                (h->recovery_frame == h->frame_num && nal->ref_idc)) {
                  h->recovery_frame         = -1;
                  h->cur_pic_ptr->recovered = 1;
              }
              // "recovered".
              if (nal->type == NAL_IDR_SLICE)
                  h->frame_recovered |= FRAME_RECOVERED_IDR;
 +#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 & AV_CODEC_FLAG2_CHUNKS))
                      decode_postinit(h, i >= nals_needed);
  
                  if (h->avctx->hwaccel &&
 -                    (ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0)) < 0)
 -                    return ret;
 +                    (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
 +                    goto end;
 +#if FF_API_CAP_VDPAU
 +                if (CONFIG_H264_VDPAU_DECODER &&
 +                    h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU)
 +                    ff_vdpau_h264_picture_start(h);
 +#endif
              }
  
 -            if (sl->redundant_pic_count == 0 &&
 -                (avctx->skip_frame < AVDISCARD_NONREF || nal->ref_idc) &&
 -                (avctx->skip_frame < AVDISCARD_BIDIR  ||
 -                 sl->slice_type_nos != AV_PICTURE_TYPE_B) &&
 -                (avctx->skip_frame < AVDISCARD_NONKEY ||
 -                 h->cur_pic_ptr->f->key_frame) &&
 -                avctx->skip_frame < AVDISCARD_ALL) {
 +            if (sl->redundant_pic_count == 0) {
                  if (avctx->hwaccel) {
 -                    ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
 +                    ret = avctx->hwaccel->decode_slice(avctx,
 +                                                       nal->raw_data,
 +                                                       nal->raw_size);
                      if (ret < 0)
 -                        return ret;
 +                        goto end;
 +#if FF_API_CAP_VDPAU
 +                } else if (CONFIG_H264_VDPAU_DECODER &&
 +                           h->avctx->codec->capabilities & AV_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],
 +                                            nal->raw_data,
 +                                            nal->raw_size);
 +#endif
                  } else
                      context_count++;
              }
          case NAL_DPB:
          case NAL_DPC:
              avpriv_request_sample(avctx, "data partitioning");
 -            ret = AVERROR(ENOSYS);
 -            goto end;
              break;
          case NAL_SEI:
              h->gb = nal->gb;
              if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                  goto end;
              break;
--        case NAL_SPS:
-             h->gb = nal->gb;
-             if (ff_h264_decode_seq_parameter_set(h, 0) >= 0)
 -            ret = ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps);
 -            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
 -                goto end;
++        case NAL_SPS: {
++            GetBitContext tmp_gb = nal->gb;
++            if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
 +                break;
 +            av_log(h->avctx, AV_LOG_DEBUG,
 +                   "SPS decoding failure, trying again with the complete NAL\n");
-             init_get_bits8(&h->gb, nal->raw_data + 1, nal->raw_size - 1);
-             if (ff_h264_decode_seq_parameter_set(h, 0) >= 0)
++            init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
++            if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
 +                break;
-             h->gb = nal->gb;
-             ff_h264_decode_seq_parameter_set(h, 1);
++            ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
              break;
++        }
          case NAL_PPS:
-             h->gb = nal->gb;
-             ret = ff_h264_decode_picture_parameter_set(h, nal->size_bits);
+             ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
+                                                        nal->size_bits);
              if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                  goto end;
              break;
              context_count = 0;
          }
  
 -        if (err < 0) {
 -            av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
 +        if (err < 0 || err == SLICE_SKIPED) {
 +            if (err < 0)
 +                av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
              sl->ref_count[0] = sl->ref_count[1] = sl->list_count = 0;
 -        } else if (err == 1) {
 +        } else if (err == SLICE_SINGLETHREAD) {
 +            if (context_count > 0) {
 +                ret = ff_h264_execute_decode_slices(h, context_count);
 +                if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
 +                    goto end;
 +                context_count = 0;
 +            }
              /* Slice could not be decoded in parallel mode, restart. Note
               * that rbsp_buffer is not transferred, but since we no longer
               * run in parallel mode this should not be an issue. */
  
      ret = 0;
  end:
-     if (!FIELD_PICTURE(h) && h->current_slice && !h->sps.new && h->enable_er) {
 +
 +#if CONFIG_ERROR_RESILIENCE
 +    /*
 +     * FIXME: Error handling code does not seem to support interlaced
 +     * when slices span multiple rows
 +     * The ff_er_add_slice calls don't work right for bottom
 +     * fields; they cause massive erroneous error concealing
 +     * Error marking covers both fields (top and bottom).
 +     * This causes a mismatched s->error_count
 +     * and a bad error table. Further, the error count goes to
 +     * INT_MAX when called for bottom field, because mb_y is
 +     * past end by one (callers fault) and resync_mb_y != 0
 +     * causes problems for the first MB line, too.
 +     */
++    if (!FIELD_PICTURE(h) && h->current_slice &&
++        h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
++        h->enable_er) {
++
 +        H264SliceContext *sl = h->slice_ctx;
 +        int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];
 +
 +        ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);
 +
 +        if (use_last_pic) {
 +            ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
 +            sl->ref_list[0][0].parent = &h->last_pic_for_ec;
 +            memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
 +            memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
 +            sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
 +        } else if (sl->ref_count[0]) {
 +            ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
 +        } else
 +            ff_h264_set_erpic(&sl->er.last_pic, NULL);
 +
 +        if (sl->ref_count[1])
 +            ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);
 +
 +        sl->er.ref_count = sl->ref_count[0];
 +
 +        ff_er_frame_end(&sl->er);
 +        if (use_last_pic)
 +            memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
 +    }
 +#endif /* CONFIG_ERROR_RESILIENCE */
      /* clean up */
      if (h->cur_pic_ptr && !h->droppable) {
          ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
@@@ -1354,62 -1191,26 +1354,62 @@@ 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->ps.sps || !h->ps.sps->crop)
 +    av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(h), 0);
 +
 +    h->backup_width   = h->avctx->width;
 +    h->backup_height  = h->avctx->height;
 +    h->backup_pix_fmt = h->avctx->pix_fmt;
 +
 +    h->avctx->width   = dst->width;
 +    h->avctx->height  = dst->height;
 +    h->avctx->pix_fmt = dst->format;
 +
 +    if (srcp->sei_recovery_frame_cnt == 0)
 +        dst->key_frame = 1;
 +    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->ps.sps->crop_left >> hshift) << h->pixel_shift) +
 -                     (h->ps.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;
  }
  
 +static int is_extra(const uint8_t *buf, int buf_size)
 +{
 +    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] & 0x9F) != 7)
 +            return 0;
 +        p += nalsize;
 +    }
 +    cnt = *(p++);
 +    if(!cnt)
 +        return 0;
 +    while(cnt--){
 +        int nalsize= AV_RB16(p) + 2;
 +        if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
 +            return 0;
 +        p += nalsize;
 +    }
 +    return 1;
 +}
 +
  static int h264_decode_frame(AVCodecContext *avctx, void *data,
                               int *got_frame, AVPacket *avpkt)
  {
      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->setup_finished = 0;
  
 +    if (h->backup_width != -1) {
 +        avctx->width    = h->backup_width;
 +        h->backup_width = -1;
 +    }
 +    if (h->backup_height != -1) {
 +        avctx->height    = h->backup_height;
 +        h->backup_height = -1;
 +    }
 +    if (h->backup_pix_fmt != AV_PIX_FMT_NONE) {
 +        avctx->pix_fmt    = h->backup_pix_fmt;
 +        h->backup_pix_fmt = AV_PIX_FMT_NONE;
 +    }
 +
 +    ff_h264_unref_picture(h, &h->last_pic_for_ec);
 +
      /* 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 && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
 +        int side_size;
 +        uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
 +        if (is_extra(side, side_size))
 +            ff_h264_decode_extradata(h, side, side_size);
 +    }
 +    if(h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC && (buf[5]&0x1F) && buf[8]==0x67){
 +        if (is_extra(buf, buf_size))
 +            return ff_h264_decode_extradata(h, buf, buf_size);
 +    }
  
      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 & AV_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;
      }
          if (avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)
              decode_postinit(h, 1);
  
 -        ff_h264_field_end(h, &h->slice_ctx[0], 0);
 +        if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
 +            return ret;
  
 +        /* Wait for second field. */
          *got_frame = 0;
          if (h->next_output_pic && ((avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
 +                                   (avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
                                     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);
 +            if (!h->avctx->hwaccel &&
 +                 (h->next_output_pic->field_poc[0] == INT_MAX ||
 +                  h->next_output_pic->field_poc[1] == INT_MAX)
 +            ) {
 +                int p;
 +                AVFrame *f = h->next_output_pic->f;
 +                int field = h->next_output_pic->field_poc[0] == INT_MAX;
 +                uint8_t *dst_data[4];
 +                int linesizes[4];
 +                const uint8_t *src_data[4];
 +
 +                av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);
 +
 +                for (p = 0; p<4; p++) {
 +                    dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
 +                    src_data[p] = f->data[p] +  field   *f->linesize[p];
 +                    linesizes[p] = 2*f->linesize[p];
 +                }
 +
 +                av_image_copy(dst_data, linesizes, src_data, linesizes,
 +                              f->format, f->width, f->height>>1);
 +            }
 +
 +            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, pict, NULL,
 +                                    h->next_output_pic->mb_type,
 +                                    h->next_output_pic->qscale_table,
 +                                    h->next_output_pic->motion_val,
 +                                    &h->low_delay,
 +                                    h->mb_width, h->mb_height, h->mb_stride, 1);
 +            }
          }
      }
  
 -    assert(pict->buf[0] || !*got_frame);
 +    av_assert0(pict->buf[0] || !*got_frame);
 +
 +    ff_h264_unref_picture(h, &h->last_pic_for_ec);
  
      return get_consumed_bytes(buf_index, buf_size);
  }
@@@ -1572,7 -1309,6 +1572,7 @@@ av_cold void ff_h264_free_context(H264C
          ff_h264_unref_picture(h, &h->DPB[i]);
          av_frame_free(&h->DPB[i].f);
      }
 +    memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
  
      h->cur_pic_ptr = NULL;
  
      av_freep(&h->slice_ctx);
      h->nb_slice_ctx = 0;
  
 +    h->a53_caption_size = 0;
 +    av_freep(&h->a53_caption);
 +
      for (i = 0; i < MAX_SPS_COUNT; i++)
-         av_freep(h->sps_buffers + i);
+         av_buffer_unref(&h->ps.sps_list[i]);
  
      for (i = 0; i < MAX_PPS_COUNT; i++)
-         av_freep(h->pps_buffers + i);
+         av_buffer_unref(&h->ps.pps_list[i]);
++    av_buffer_unref(&h->ps.sps_ref);
++    av_buffer_unref(&h->ps.pps_ref);
 +
      ff_h2645_packet_uninit(&h->pkt);
  }
  
@@@ -1597,13 -1330,10 +1600,13 @@@ static av_cold int h264_decode_end(AVCo
  {
      H264Context *h = avctx->priv_data;
  
 +    ff_h264_remove_all_refs(h);
      ff_h264_free_context(h);
  
      ff_h264_unref_picture(h, &h->cur_pic);
      av_frame_free(&h->cur_pic.f);
 +    ff_h264_unref_picture(h, &h->last_pic_for_ec);
 +    av_frame_free(&h->last_pic_for_ec.f);
  
      return 0;
  }
  #define OFFSET(x) offsetof(H264Context, x)
  #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
  static const AVOption h264_options[] = {
 -    { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
 +    {"is_avc", "is avc", offsetof(H264Context, is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0},
 +    {"nal_length_size", "nal_length_size", offsetof(H264Context, nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0},
 +    { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
      { NULL },
  };
  
  static const AVClass h264_class = {
 -    .class_name = "h264",
 +    .class_name = "H264 Decoder",
      .item_name  = av_default_item_name,
      .option     = h264_options,
      .version    = LIBAVUTIL_VERSION_INT,
@@@ -1643,29 -1371,3 +1646,29 @@@ AVCodec ff_h264_decoder = 
      .profiles              = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
      .priv_class            = &h264_class,
  };
 +
 +#if CONFIG_H264_VDPAU_DECODER && FF_API_VDPAU
 +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_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   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_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(ff_h264_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
   */
  
@@@ -28,6 -28,7 +28,7 @@@
  #ifndef AVCODEC_H264_H
  #define AVCODEC_H264_H
  
+ #include "libavutil/buffer.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/thread.h"
  #include "cabac.h"
@@@ -46,8 -47,8 +47,8 @@@
  #include "rectangle.h"
  #include "videodsp.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
@@@ -56,8 -57,6 +57,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
  #define MAX_SLICES 32
  
  #ifdef ALLOW_INTERLACE
 -#define MB_MBAFF(h)    h->mb_mbaff
 -#define MB_FIELD(h)    h->mb_field_decoding_flag
 -#define FRAME_MBAFF(h) h->mb_aff_frame
 -#define FIELD_PICTURE(h) (h->picture_structure != PICT_FRAME)
 +#define MB_MBAFF(h)    (h)->mb_mbaff
 +#define MB_FIELD(sl)  (sl)->mb_field_decoding_flag
 +#define FRAME_MBAFF(h) (h)->mb_aff_frame
 +#define FIELD_PICTURE(h) ((h)->picture_structure != PICT_FRAME)
  #define LEFT_MBS 2
  #define LTOP     0
  #define LBOT     1
  #define LEFT(i)  (i)
  #else
  #define MB_MBAFF(h)      0
 -#define MB_FIELD(h)      0
 +#define MB_FIELD(sl)     0
  #define FRAME_MBAFF(h)   0
  #define FIELD_PICTURE(h) 0
  #undef  IS_INTERLACED
  #define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
  
  #ifndef CABAC
- #define CABAC(h) (h)->pps.cabac
 -#define CABAC(h) h->ps.pps->cabac
++#define CABAC(h) (h)->ps.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 CHROMA422(h) (h->ps.sps->chroma_format_idc == 2)
 -#define CHROMA444(h) (h->ps.sps->chroma_format_idc == 3)
++#define CHROMA(h)    ((h)->ps.sps->chroma_format_idc)
++#define CHROMA422(h) ((h)->ps.sps->chroma_format_idc == 2)
++#define CHROMA444(h) ((h)->ps.sps->chroma_format_idc == 3)
  
  #define EXTENDED_SAR       255
  
  #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 {
@@@ -140,7 -138,6 +141,7 @@@ typedef enum 
      SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
      SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
      SEI_TYPE_DISPLAY_ORIENTATION    = 47,  ///< display orientation
 +    SEI_TYPE_GREEN_METADATA         = 56   ///< GreenMPEG information
  } SEI_Type;
  
  /**
@@@ -159,19 -156,6 +160,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 {
      int bit_depth_chroma;                 ///< bit_depth_chroma_minus8 + 8
      int residual_color_transform_flag;    ///< residual_colour_transform_flag
      int constraint_set_flags;             ///< constraint_set[0-3]_flag
-     int new;                              ///< flag to keep track if the decoder context needs re-init due to changed SPS
 +    uint8_t data[4096];
 +    size_t data_size;
  } SPS;
  
  /**
@@@ -257,41 -238,26 +257,58 @@@ 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;
 +    uint8_t data[4096];
 +    size_t data_size;
+     uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16];
+     uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
+     uint32_t(*dequant4_coeff[6])[16];
+     uint32_t(*dequant8_coeff[6])[64];
  } PPS;
  
+ typedef struct H264ParamSets {
+     AVBufferRef *sps_list[MAX_SPS_COUNT];
+     AVBufferRef *pps_list[MAX_PPS_COUNT];
++    AVBufferRef *pps_ref;
++    AVBufferRef *sps_ref;
+     /* currently active parameters sets */
+     const PPS *pps;
+     // FIXME this should properly be const
+     SPS *sps;
+ } H264ParamSets;
  /**
 + * 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;
 +
 +/**
 + *     Green MetaData Information Type
 + */
 +typedef struct GreenMetaData {
 +    uint8_t  green_metadata_type;
 +    uint8_t  period_type;
 +    uint16_t  num_seconds;
 +    uint16_t  num_pictures;
 +    uint8_t percent_non_zero_macroblocks;
 +    uint8_t percent_intra_coded_macroblocks;
 +    uint8_t percent_six_tap_filtering;
 +    uint8_t percent_alpha_point_deblocking_instance;
 +    uint8_t xsd_metric_type;
 +    uint16_t xsd_metric_value;
 +} GreenMetaData;
 +
 +/**
   * Memory management control operation opcode.
   */
  typedef enum MMCOOpcode {
@@@ -340,19 -306,13 +357,19 @@@ typedef struct H264Picture 
      int pic_id;             /**< pic_num (short -> no wrap version of pic_num,
                                   pic_num & max_pic_num; long -> long_pic_num) */
      int long_ref;           ///< 1->long term reference 0->short term reference
 -    int ref_poc[2][2][32];  ///< POCs of the frames used as reference (FIXME need per slice)
 +    int ref_poc[2][2][32];  ///< POCs of the frames/fields used as reference (FIXME need per slice)
      int ref_count[2][2];    ///< number of entries in ref_poc         (FIXME need per slice)
      int mbaff;              ///< 1 -> MBAFF frame 0-> not MBAFF
      int field_picture;      ///< whether or not picture was encoded in separate fields
  
      int reference;
      int recovered;          ///< picture at IDR or recovery point + recovery count
 +    int invalid_gap;
 +    int sei_recovery_frame_cnt;
 +
 +    int crop;
 +    int crop_left;
 +    int crop_top;
  } H264Picture;
  
  typedef struct H264Ref {
@@@ -487,7 -447,7 +504,7 @@@ typedef struct H264SliceContext 
  
      DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
  
 -    ///< as a dct coeffecient is int32_t in high depth, we need to reserve twice the space.
 +    ///< as a dct coefficient is int32_t in high depth, we need to reserve twice the space.
      DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
      DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
      ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either
@@@ -523,7 -483,6 +540,7 @@@ typedef struct H264Context 
      H264Picture DPB[H264_MAX_PICTURE_COUNT];
      H264Picture *cur_pic_ptr;
      H264Picture cur_pic;
 +    H264Picture last_pic_for_ec;
  
      H264SliceContext *slice_ctx;
      int            nb_slice_ctx;
      int width, height;
      int chroma_x_shift, chroma_y_shift;
  
 +    /**
 +     * Backup frame properties: needed, because they can be different
 +     * between returned frame and last decoded frame.
 +     **/
 +    int backup_width;
 +    int backup_height;
 +    enum AVPixelFormat backup_pix_fmt;
 +
      int droppable;
      int coded_picture_number;
      int low_delay;
      uint32_t *mb2br_xy;
      int b_stride;       // FIXME use s->b4_stride
  
-     SPS sps; ///< current sps
-     PPS pps; ///< current pps
 +
 +    unsigned current_sps_id; ///< id of the current SPS
-     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];
-     uint32_t(*dequant8_coeff[6])[64];
 +
 +    int au_pps_id; ///< pps_id of current access unit
 +
      uint16_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1
  
      // interlacing specific flags
      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;
  
      int bit_depth_luma;         ///< luma bit depth from sps to detect changes
      int chroma_format_idc;      ///< chroma format from sps to detect changes
  
-     SPS *sps_buffers[MAX_SPS_COUNT];
-     PPS *pps_buffers[MAX_PPS_COUNT];
-     int dequant_coeff_pps;      ///< reinit tables when pps changes
+     H264ParamSets ps;
  
      uint16_t *slice_table_base;
  
       */
      int max_pic_num;
  
 +    H264Ref default_ref[2];
      H264Picture *short_ref[32];
      H264Picture *long_ref[32];
      H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
       * @{
       */
      /**
 -     * 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;
  
      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 frame_recovered;    ///< Initial frame has been completely recovered
  
 -    /* for frame threading, this is set to 1
 +    int has_recovery_point;
 +
 +    int missing_fields;
 +
 +/* for frame threading, this is set to 1
       * after finish_setup() has been called, so we cannot modify
       * some context properties (which are supposed to stay constant between
       * slices) anymore */
      int sei_buffering_period_present;   ///< Buffering period SEI flag
      int initial_cpb_removal_delay[32];  ///< Initial timestamps for CPBs
  
 +    int cur_chroma_format_idc;
 +    int cur_bit_depth_luma;
 +    int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 +
 +    uint8_t parse_history[6];
 +    int parse_history_count;
 +    int parse_last_mb;
 +
      int enable_er;
  
      AVBufferPool *qscale_table_pool;
      /* Motion Estimation */
      qpel_mc_func (*qpel_put)[16];
      qpel_mc_func (*qpel_avg)[16];
 +
 +    /*Green Metadata */
 +    GreenMetaData sei_green_metadata;
 +
  } H264Context;
  
  extern const uint16_t ff_h264_mb_sizes[4];
@@@ -848,17 -760,19 +855,19 @@@ int ff_h264_decode_sei(H264Context *h)
  /**
   * Decode SPS
   */
- int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation);
+ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
 -                                     H264ParamSets *ps);
++                                     H264ParamSets *ps, int ignore_truncation);
  
  /**
   * compute profile from sps
   */
- int ff_h264_get_profile(SPS *sps);
+ int ff_h264_get_profile(const SPS *sps);
  
  /**
   * Decode PPS
   */
- int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length);
+ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+                                          H264ParamSets *ps, int bit_length);
  
  /**
   * Free any data that may have been allocated in the H264 context
@@@ -892,7 -806,7 +901,7 @@@ int ff_h264_decode_ref_pic_marking(H264
  int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice);
  
  void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl);
 -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);
  
@@@ -910,7 -824,7 +919,7 @@@ int ff_h264_decode_mb_cabac(const H264C
  
  void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl);
  
--void ff_h264_init_dequant_tables(H264Context *h);
++void ff_h264_init_dequant_tables(PPS *pps, const SPS *sps);
  
  void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl);
  void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl);
@@@ -931,12 -845,6 +940,12 @@@ void ff_h264_filter_mb(const H264Contex
   */
  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
   *  / / /
@@@ -987,7 -895,7 +996,7 @@@ static const uint8_t scan8[16 * 3 + 3] 
      0 +  0 * 8, 0 +  5 * 8, 0 + 10 * 8
  };
  
 -static av_always_inline uint32_t pack16to32(int a, int b)
 +static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
  {
  #if HAVE_BIGENDIAN
      return (b & 0xFFFF) + (a << 16);
  #endif
  }
  
 -static av_always_inline uint16_t pack8to16(int a, int b)
 +static av_always_inline uint16_t pack8to16(unsigned a, unsigned b)
  {
  #if HAVE_BIGENDIAN
      return (b & 0xFF) + (a << 8);
   */
  static av_always_inline int get_chroma_qp(const H264Context *h, int t, int qscale)
  {
-     return h->pps.chroma_qp_table[t][qscale];
+     return h->ps.pps->chroma_qp_table[t][qscale];
  }
  
  /**
@@@ -1133,7 -1041,7 +1142,7 @@@ static av_always_inline void write_back
  
  static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
  {
-     if (h->sps.direct_8x8_inference_flag)
+     if (h->ps.sps->direct_8x8_inference_flag)
          return !(AV_RN64A(sl->sub_mb_type) &
                   ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) *
                    0x0001000100010001ULL));
                    0x0001000100010001ULL));
  }
  
 +static inline int find_start_code(const uint8_t *buf, int buf_size,
 +                           int buf_index, int next_avc)
 +{
 +    uint32_t state = -1;
 +
 +    buf_index = avpriv_find_start_code(buf + buf_index, buf + next_avc + 1, &state) - buf - 1;
 +
 +    return FFMIN(buf_index, buf_size);
 +}
 +
 +static inline int get_avc_nalsize(H264Context *h, const uint8_t *buf,
 +                           int buf_size, int *buf_index)
 +{
 +    int i, nalsize = 0;
 +
 +    if (*buf_index >= buf_size - h->nal_length_size) {
 +        // the end of the buffer is reached, refill it.
 +        return AVERROR(EAGAIN);
 +    }
 +
 +    for (i = 0; i < h->nal_length_size; i++)
 +        nalsize = ((unsigned)nalsize << 8) | buf[(*buf_index)++];
 +    if (nalsize <= 0 || nalsize > buf_size - *buf_index) {
 +        av_log(h->avctx, AV_LOG_ERROR,
 +               "AVC: nal size %d\n", nalsize);
 +        return AVERROR_INVALIDDATA;
 +    }
 +    return nalsize;
 +}
 +
  int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
  
  int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src);
@@@ -1184,9 -1062,6 +1193,9 @@@ void ff_h264_draw_horiz_band(const H264
  int ff_init_poc(H264Context *h, int pic_field_poc[2], int *pic_poc);
  
  int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl);
 +#define SLICE_SINGLETHREAD 1
 +#define SLICE_SKIPED 2
 +
  int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count);
  int ff_h264_update_thread_context(AVCodecContext *dst,
                                    const AVCodecContext *src);
@@@ -1195,6 -1070,4 +1204,6 @@@ void ff_h264_flush_change(H264Context *
  
  void ff_h264_free_tables(H264Context *h);
  
 +void ff_h264_set_erpic(ERPicture *dst, H264Picture *src);
 +
  #endif /* AVCODEC_H264_H */
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
  #define INT_BIT (CHAR_BIT * sizeof(int))
  
  #include "libavutil/attributes.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/timer.h"
  #include "config.h"
  #include "cabac.h"
@@@ -47,6 -45,8 +47,6 @@@
  #include "x86/h264_i386.h"
  #endif
  
 -#include <assert.h>
 -
  /* Cabac pre state table */
  
  static const int8_t cabac_context_init_I[1024][2] =
@@@ -1265,7 -1265,7 +1265,7 @@@ void ff_h264_init_cabac_states(const H2
  {
      int i;
      const int8_t (*tab)[2];
-     const int slice_qp = av_clip(sl->qscale - 6*(h->sps.bit_depth_luma-8), 0, 51);
+     const int slice_qp = av_clip(sl->qscale - 6*(h->ps.sps->bit_depth_luma-8), 0, 51);
  
      if (sl->slice_type_nos == AV_PICTURE_TYPE_I) tab = cabac_context_init_I;
      else                                 tab = cabac_context_init_PB[sl->cabac_init_idc];
  
  static int decode_cabac_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
  {
 -    const long mbb_xy = sl->mb_xy - 2L*h->mb_stride;
 +    const int mbb_xy = sl->mb_xy - 2*h->mb_stride;
  
      unsigned long ctx = 0;
  
@@@ -1501,7 -1501,7 +1501,7 @@@ static int decode_cabac_mb_mvd(H264Slic
      int mvd;
  
      if(!get_cabac(&sl->cabac, &sl->cabac_state[ctxbase+((amvd-3)>>(INT_BIT-1))+((amvd-33)>>(INT_BIT-1))+2])){
 -//    if(!get_cabac(&h->cabac, &h->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
 +//    if(!get_cabac(&sl->cabac, &sl->cabac_state[ctxbase+(amvd>2)+(amvd>32)])){
          *mvda= 0;
          return 0;
      }
      int amvd1 = sl->mvd_cache[list][scan8[n] - 1][1] +\
                  sl->mvd_cache[list][scan8[n] - 8][1];\
  \
 -    mx += decode_cabac_mb_mvd(sl, 40, amvd0, &mpx);\
 -    my += decode_cabac_mb_mvd(sl, 47, amvd1, &mpy);\
 +    int mxd = decode_cabac_mb_mvd(sl, 40, amvd0, &mpx);\
 +    int myd = decode_cabac_mb_mvd(sl, 47, amvd1, &mpy);\
 +    if (mxd == INT_MIN || myd == INT_MIN) \
 +        return AVERROR_INVALIDDATA; \
 +    mx += mxd;\
 +    my += myd;\
  }
  
  static av_always_inline int get_cabac_cbf_ctx(H264SliceContext *sl,
@@@ -1644,9 -1640,7 +1644,9 @@@ decode_cabac_residual_internal(const H2
      cc.range     = sl->cabac.range;
      cc.low       = sl->cabac.low;
      cc.bytestream= sl->cabac.bytestream;
 +#if !UNCHECKED_BITSTREAM_READER || ARCH_AARCH64
      cc.bytestream_end = sl->cabac.bytestream_end;
 +#endif
  #else
  #define CC &sl->cabac
  #endif
          }
  #endif
      }
 -    assert(coeff_count > 0);
 +    av_assert2(coeff_count > 0);
  
      if( is_dc ) {
          if( cat == 3 )
          if( max_coeff == 64 )
              fill_rectangle(&sl->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 );
              sl->non_zero_count_cache[scan8[n]] = coeff_count;
          }
      }
@@@ -1876,7 -1870,7 +1876,7 @@@ static av_always_inline void decode_cab
          decode_cabac_residual_dc(h, sl, sl->mb_luma_dc[p], ctx_cat[0][p], LUMA_DC_BLOCK_INDEX+p, scan, 16);
  
          if( cbp&15 ) {
-             qmul = h->dequant4_coeff[p][qscale];
+             qmul = h->ps.pps->dequant4_coeff[p][qscale];
              for( i4x4 = 0; i4x4 < 16; i4x4++ ) {
                  const int index = 16*p + i4x4;
                  decode_cabac_residual_nondc(h, sl, sl->mb + (16*index << pixel_shift), ctx_cat[1][p], index, scan + 1, qmul, 15);
                  if( IS_8x8DCT(mb_type) ) {
                      const int index = 16*p + 4*i8x8;
                      decode_cabac_residual_nondc(h, sl, sl->mb + (16*index << pixel_shift), ctx_cat[3][p], index,
-                                                 scan8x8, h->dequant8_coeff[cqm][qscale], 64);
+                                                 scan8x8, h->ps.pps->dequant8_coeff[cqm][qscale], 64);
                  } else {
-                     qmul = h->dequant4_coeff[cqm][qscale];
+                     qmul = h->ps.pps->dequant4_coeff[cqm][qscale];
                      for( i4x4 = 0; i4x4 < 4; i4x4++ ) {
                          const int index = 16*p + 4*i8x8 + i4x4;
  //START_TIMER
   */
  int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
  {
+     const SPS *sps = h->ps.sps;
      int mb_xy;
      int mb_type, partition_count, cbp = 0;
-     int dct8x8_allowed= h->pps.transform_8x8_mode;
-     int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
+     int dct8x8_allowed= h->ps.pps->transform_8x8_mode;
+     int decode_chroma = sps->chroma_format_idc == 1 || sps->chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
  
      mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
  
      if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
          int ctx = 0;
 -        assert(sl->slice_type_nos == AV_PICTURE_TYPE_B);
 +        av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_B);
  
          if (!IS_DIRECT(sl->left_type[LTOP] - 1))
              ctx++;
          mb_type = decode_cabac_intra_mb_type(sl, 3, 1);
          if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
              mb_type--;
 -        assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 +        av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
  decode_intra_mb:
          partition_count = 0;
          cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
      h->slice_table[mb_xy] = sl->slice_num;
  
      if(IS_INTRA_PCM(mb_type)) {
-         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
-                             h->sps.bit_depth_luma >> 3;
+         const int mb_size = ff_h264_mb_sizes[sps->chroma_format_idc] *
+                             sps->bit_depth_luma >> 3;
          const uint8_t *ptr;
 +        int ret;
  
          // We assume these blocks are very rare so we do not optimize it.
          // FIXME The two following lines get the bitstream position in the cabac
          sl->intra_pcm_ptr = ptr;
          ptr += mb_size;
  
 -        ff_init_cabac_decoder(&sl->cabac, ptr, sl->cabac.bytestream_end - ptr);
 +        ret = ff_init_cabac_decoder(&sl->cabac, ptr, sl->cabac.bytestream_end - ptr);
 +        if (ret < 0)
 +            return ret;
  
          // All blocks are present
          h->cbp_table[mb_xy] = 0xf7ef;
                      int pred = pred_intra_mode(h, sl, i);
                      sl->intra4x4_pred_mode_cache[scan8[i]] = decode_cabac_mb_intra4x4_pred_mode(sl, pred);
  
 -                    ff_dlog(h->avctx, "i4x4 pred=%d mode=%d\n", pred,
 +                    ff_tlog(h->avctx, "i4x4 pred=%d mode=%d\n", pred,
                              sl->intra4x4_pred_mode_cache[scan8[i]]);
                  }
              }
                  for( i = 0; i < 4; i++ ) {
                      if(IS_DIRECT(sl->sub_mb_type[i])) continue;
                      if(IS_DIR(sl->sub_mb_type[i], 0, list)){
 -                        int rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                        unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                          if (rc > 1) {
                              ref[list][i] = decode_cabac_mb_ref(sl, list, 4 * i);
 -                            if (ref[list][i] >= (unsigned) rc) {
 +                            if (ref[list][i] >= rc) {
                                  av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref[list][i], rc);
                                  return -1;
                              }
          ff_h264_pred_direct_motion(h, sl, &mb_type);
          fill_rectangle(sl->mvd_cache[0][scan8[0]], 4, 4, 8, 0, 2);
          fill_rectangle(sl->mvd_cache[1][scan8[0]], 4, 4, 8, 0, 2);
-         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
+         dct8x8_allowed &= sps->direct_8x8_inference_flag;
      } else {
          int list, i;
          if(IS_16X16(mb_type)){
              for (list = 0; list < sl->list_count; list++) {
                  if(IS_DIR(mb_type, 0, list)){
 -                    int ref, rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                    int ref;
 +                    unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                      if (rc > 1) {
                          ref= decode_cabac_mb_ref(sl, list, 0);
 -                        if (ref >= (unsigned) rc) {
 +                        if (ref >= rc) {
                              av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
                              return -1;
                          }
              for (list = 0; list < sl->list_count; list++) {
                      for(i=0; i<2; i++){
                          if(IS_DIR(mb_type, i, list)){
 -                            int ref, rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                            int ref;
 +                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                              if (rc > 1) {
                                  ref= decode_cabac_mb_ref(sl, list, 8 * i);
 -                                if (ref >= (unsigned) rc) {
 +                                if (ref >= rc) {
                                      av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
                                      return -1;
                                  }
                  }
              }
          }else{
 -            assert(IS_8X16(mb_type));
 +            av_assert2(IS_8X16(mb_type));
              for (list = 0; list < sl->list_count; list++) {
                      for(i=0; i<2; i++){
                          if(IS_DIR(mb_type, i, list)){ //FIXME optimize
 -                            int ref, rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                            int ref;
 +                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                              if (rc > 1) {
                                  ref = decode_cabac_mb_ref(sl, list, 4 * i);
 -                                if (ref >= (unsigned) rc) {
 +                                if (ref >= rc) {
                                      av_log(h->avctx, AV_LOG_ERROR, "Reference %d >= %d\n", ref, rc);
                                      return -1;
                                  }
          cbp  = decode_cabac_mb_cbp_luma(sl);
          if(decode_chroma)
              cbp |= decode_cabac_mb_cbp_chroma(sl) << 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] = sl->cbp = cbp;
          if(get_cabac_noinline( &sl->cabac, &sl->cabac_state[60 + (sl->last_qscale_diff != 0)])){
              int val = 1;
              int ctx= 2;
-             const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
+             const int max_qp = 51 + 6*(sps->bit_depth_luma-8);
  
              while( get_cabac_noinline( &sl->cabac, &sl->cabac_state[60 + ctx] ) ) {
                  ctx= 3;
                  int c, i, i8x8;
                  for( c = 0; c < 2; c++ ) {
                      int16_t *mb = sl->mb + (16*(16 + 16*c) << pixel_shift);
-                     qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[c]];
+                     qmul = h->ps.pps->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[c]];
                      for (i8x8 = 0; i8x8 < 2; i8x8++) {
                          for (i = 0; i < 4; i++) {
                              const int index = 16 + 16 * c + 8*i8x8 + i;
              if( cbp&0x20 ) {
                  int c, i;
                  for( c = 0; c < 2; c++ ) {
-                     qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[c]];
+                     qmul = h->ps.pps->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[c]];
                      for( i = 0; i < 4; i++ ) {
                          const int index = 16 + 16 * c + i;
                          decode_cabac_residual_nondc(h, sl, sl->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);
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,8 +35,8 @@@
  #include "h264data.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,
@@@ -361,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];
@@@ -481,7 -480,7 +481,7 @@@ static int decode_residual(const H264Co
  
      trailing_ones= coeff_token&3;
      ff_tlog(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", sl->mb_x, sl->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", sl->mb_x, sl->mb_y);
 +        return -1;
 +    }
 +
      return 0;
  }
  
@@@ -649,14 -642,14 +649,14 @@@ int decode_luma_residual(const H264Cont
              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++){
                  for(i4x4=0; i4x4<4; i4x4++){
                      const int index= i4x4 + 4*i8x8 + p*16;
                      if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
-                         index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
+                         index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
                          return -1;
                      }
                  }
                      for(i4x4=0; i4x4<4; i4x4++){
                          const int index= i4x4 + 4*i8x8 + p*16;
                          if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
-                                             h->dequant8_coeff[cqm][qscale], 16) < 0 )
+                                             h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
                              return -1;
                      }
                      nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
                      for(i4x4=0; i4x4<4; i4x4++){
                          const int index= i4x4 + 4*i8x8 + p*16;
                          if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
-                                             scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
+                                             scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
                              return -1;
                          }
                          new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
@@@ -708,8 -701,8 +708,8 @@@ int ff_h264_decode_mb_cavlc(const H264C
      int mb_xy;
      int partition_count;
      unsigned int mb_type, cbp;
-     int dct8x8_allowed= h->pps.transform_8x8_mode;
-     int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
+     int dct8x8_allowed= h->ps.pps->transform_8x8_mode;
+     int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
      const int pixel_shift = h->pixel_shift;
  
      mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
                  down the code */
      if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
          if (sl->mb_skip_run == -1)
 -            sl->mb_skip_run = get_ue_golomb(&sl->gb);
 +            sl->mb_skip_run = get_ue_golomb_long(&sl->gb);
  
          if (sl->mb_skip_run--) {
              if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
              goto decode_intra_mb;
          }
      }else{
 -       assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 +       av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
          if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
              mb_type--;
  decode_intra_mb:
      h->slice_table[mb_xy] = sl->slice_num;
  
      if(IS_INTRA_PCM(mb_type)){
-         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
-                             h->sps.bit_depth_luma;
+         const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
+                             h->ps.sps->bit_depth_luma;
  
          // We assume these blocks are very rare so we do not optimize it.
          sl->intra_pcm_ptr = align_get_bits(&sl->gb);
                  sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
              }
          }else{
 -            assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
 +            av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
              for(i=0; i<4; i++){
                  sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
                  if(sl->sub_mb_type[i] >=4){
          }
      }else if(IS_DIRECT(mb_type)){
          ff_h264_pred_direct_motion(h, sl, &mb_type);
-         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
+         dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
      }else{
          int list, mx, my, i;
           //FIXME we should set ref_idx_l? to 0 if we use that later ...
              for (list = 0; list < sl->list_count; list++) {
                      unsigned int val;
                      if(IS_DIR(mb_type, 0, list)){
 -                        int rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                        unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                          if (rc == 1) {
                              val= 0;
                          } else if (rc == 2) {
                      for(i=0; i<2; i++){
                          unsigned int val;
                          if(IS_DIR(mb_type, i, list)){
 -                            int rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                              if (rc == 1) {
                                  val= 0;
                              } else if (rc == 2) {
                  }
              }
          }else{
 -            assert(IS_8X16(mb_type));
 +            av_assert2(IS_8X16(mb_type));
              for (list = 0; list < sl->list_count; list++) {
                      for(i=0; i<2; i++){
                          unsigned int val;
                          if(IS_DIR(mb_type, i, list)){ //FIXME optimize
 -                            int rc = sl->ref_count[list] << MB_MBAFF(sl);
 +                            unsigned rc = sl->ref_count[list] << MB_MBAFF(sl);
                              if (rc == 1) {
                                  val= 0;
                              } else if (rc == 2) {
              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)){
          int ret;
          GetBitContext *gb = &sl->gb;
          const uint8_t *scan, *scan8x8;
-         const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
+         const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
  
          if(IS_INTERLACED(mb_type)){
              scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
              if (decode_luma_residual(h, sl, 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;
++            const int num_c8x8 = h->ps.sps->chroma_format_idc;
 +
              if(cbp&0x30){
                  for(chroma_idx=0; chroma_idx<2; chroma_idx++)
                      if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
 -                                        CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_chroma422_dc_scan,
 -                                        NULL, 8) < 0) {
 +                                        CHROMA_DC_BLOCK_INDEX + chroma_idx,
 +                                        CHROMA422(h) ? ff_h264_chroma422_dc_scan : ff_h264_chroma_dc_scan,
 +                                        NULL, 4 * num_c8x8) < 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)][sl->chroma_qp[chroma_idx]];
+                     const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
                      int16_t *mb = sl->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, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
                  fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
                  fill_rectangle(&sl->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, sl, gb, sl->mb + ((256 + 16 * 16 * chroma_idx) << pixel_shift),
 -                                        CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_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->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
 -                    for(i4x4=0; i4x4<4; i4x4++){
 -                        const int index= 16 + 16*chroma_idx + i4x4;
 -                        if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
 -                            return -1;
 -                        }
 -                    }
 -                }
 -            }else{
 -                fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
 -                fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
 -            }
          }
      }else{
          fill_rectangle(&sl->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
   */
  
@@@ -137,10 -137,6 +137,10 @@@ void ff_h264_direct_ref_list_init(cons
      if (h->picture_structure == PICT_FRAME) {
          int cur_poc  = h->cur_pic_ptr->poc;
          int *col_poc = sl->ref_list[1][0].parent->field_poc;
 +        if (col_poc[0] == INT_MAX && col_poc[1] == INT_MAX) {
 +            av_log(h->avctx, AV_LOG_ERROR, "co located POCs unavailable\n");
 +            sl->col_parity = 1;
 +        } else
          sl->col_parity = (FFABS(col_poc[0] - cur_poc) >=
                            FFABS(col_poc[1] - cur_poc));
          ref1sidx =
      }
  }
  
 -static void await_reference_mb_row(const H264Context *const h, H264Picture *ref,
 +static void await_reference_mb_row(const H264Context *const h, H264Ref *ref,
                                     int mb_y)
  {
      int ref_field         = ref->reference - 1;
 -    int ref_field_picture = ref->field_picture;
 +    int ref_field_picture = ref->parent->field_picture;
      int ref_height        = 16 * h->mb_height >> ref_field_picture;
  
      if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_FRAME))
      /* FIXME: It can be safe to access mb stuff
       * even if pixels aren't deblocked yet. */
  
 -    ff_thread_await_progress(&ref->tf,
 +    ff_thread_await_progress(&ref->parent->tf,
                               FFMIN(16 * mb_y >> ref_field_picture,
                                     ref_height - 1),
                               ref_field_picture && ref_field);
@@@ -200,7 -196,7 +200,7 @@@ static void pred_spatial_direct_motion(
  
      assert(sl->ref_list[1][0].reference & 3);
  
 -    await_reference_mb_row(h, sl->ref_list[1][0].parent,
 +    await_reference_mb_row(h, &sl->ref_list[1][0],
                             sl->mb_y + !!IS_INTERLACED(*mb_type));
  
  #define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16 | MB_TYPE_INTRA4x4 | \
                  else
                      mv[list] = AV_RN32A(C);
              }
 +            av_assert2(ref[list] < (sl->ref_count[list] << !!FRAME_MBAFF(h)));
          } else {
              int mask = ~(MB_TYPE_L0 << (2 * list));
              mv[list]  = 0;
@@@ -315,7 -310,7 +315,7 @@@ single_col
                  *mb_type |= MB_TYPE_DIRECT2 |
                              (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
              } else {
-                 if (!h->sps.direct_8x8_inference_flag) {
+                 if (!h->ps.sps->direct_8x8_inference_flag) {
                      /* FIXME: Save sub mb types from previous frames (or derive
                       * from MVs) so we know exactly what block size to use. */
                      sub_mb_type += (MB_TYPE_8x8 - MB_TYPE_16x16); /* B_SUB_4x4 */
          }
      }
  
 -    await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);
 +    await_reference_mb_row(h, &sl->ref_list[1][0], mb_y);
  
 -    l1mv0  = &sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
 -    l1mv1  = &sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
 +    l1mv0  = (void*)&sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
 +    l1mv1  = (void*)&sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
      l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];
      l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];
      if (!b8_stride) {
@@@ -484,7 -479,7 +484,7 @@@ static void pred_temp_direct_motion(con
  
      assert(sl->ref_list[1][0].reference & 3);
  
 -    await_reference_mb_row(h, sl->ref_list[1][0].parent,
 +    await_reference_mb_row(h, &sl->ref_list[1][0],
                             sl->mb_y + !!IS_INTERLACED(*mb_type));
  
      if (IS_INTERLACED(sl->ref_list[1][0].parent->mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL
@@@ -538,7 -533,7 +538,7 @@@ single_col
                  *mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |
                              (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
              } else {
-                 if (!h->sps.direct_8x8_inference_flag) {
+                 if (!h->ps.sps->direct_8x8_inference_flag) {
                      /* FIXME: save sub mb types from previous frames (or derive
                       * from MVs) so we know exactly what block size to use */
                      sub_mb_type = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
          }
      }
  
 -    await_reference_mb_row(h, sl->ref_list[1][0].parent, mb_y);
 +    await_reference_mb_row(h, &sl->ref_list[1][0], mb_y);
  
 -    l1mv0  = &sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
 -    l1mv1  = &sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
 +    l1mv0  = (void*)&sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
 +    l1mv1  = (void*)&sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
      l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];
      l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];
      if (!b8_stride) {
  
          if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {
              int y_shift = 2 * !IS_INTERLACED(*mb_type);
-             assert(h->sps.direct_8x8_inference_flag);
+             assert(h->ps.sps->direct_8x8_inference_flag);
  
              for (i8 = 0; i8 < 4; i8++) {
                  const int x8 = i8 & 1;
@@@ -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
   */
  
@@@ -34,6 -34,8 +34,6 @@@
  #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,
@@@ -242,7 -244,7 +242,7 @@@ static av_always_inline void h264_filte
                                                            unsigned int uvlinesize,
                                                            int pixel_shift)
  {
 -    int chroma = !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
 +    int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
      int chroma444 = CHROMA444(h);
      int chroma422 = CHROMA422(h);
  
      int left_type = sl->left_type[LTOP];
      int top_type  = sl->top_type;
  
-     int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
+     int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8);
      int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset;
      int b = 52 + sl->slice_beta_offset - qp_bd_offset;
  
          }
          return;
      } else {
 -        LOCAL_ALIGNED_8(int16_t, bS, [2], [4][4]);
 +        LOCAL_ALIGNED(8, int16_t, bS, [2], [4][4]);
          int edges;
          if( IS_8x8DCT(mb_type) && (sl->cbp&7) == 7 && !chroma444 ) {
              edges = 4;
@@@ -419,8 -421,8 +419,8 @@@ void ff_h264_filter_mb_fast(const H264C
                              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) {
+     if(!h->h264dsp.h264_loop_filter_strength || h->ps.pps->chroma_qp_diff) {
          ff_h264_filter_mb(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize);
          return;
      }
@@@ -505,7 -507,7 +505,7 @@@ static av_always_inline void filter_mb_
              int j;
  
              for(j=0; j<2; j++, mbn_xy += h->mb_stride){
 -                DECLARE_ALIGNED(8, int16_t, bS)[4];
 +                LOCAL_ALIGNED(8, int16_t, bS, [4]);
                  int qp;
                  if (IS_INTRA(mb_type | h->cur_pic.mb_type[mbn_xy])) {
                      AV_WN64A(bS, 0x0003000300030003ULL);
                  }
              }
          }else{
 -            DECLARE_ALIGNED(8, int16_t, bS)[4];
 +            LOCAL_ALIGNED(8, int16_t, bS, [4]);
              int qp;
  
              if( IS_INTRA(mb_type|mbm_type)) {
              // 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;
 +                //ff_tlog(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]);
                  ff_tlog(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++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(h->avctx, "\n"); }
                  chroma_qp_avg[0] = (sl->chroma_qp[0] + get_chroma_qp(h, 0, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  chroma_qp_avg[1] = (sl->chroma_qp[1] + get_chroma_qp(h, 1, h->cur_pic.qscale_table[mbm_xy]) + 1) >> 1;
                  if( dir == 0 ) {
  
      /* Calculate bS */
      for( edge = 1; edge < edges; edge++ ) {
 -        DECLARE_ALIGNED(8, int16_t, bS)[4];
 +        LOCAL_ALIGNED(8, int16_t, bS, [4]);
          int qp;
          const int deblock_edge = !IS_8x8DCT(mb_type & (edge<<24)); // (edge&1) && IS_8x8DCT(mb_type)
  
          // 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];
 +        //ff_tlog(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]);
          ff_tlog(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++) ff_tlog(h->avctx, " bS[%d]:%d", i, bS[i]); ff_tlog(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) {
@@@ -723,8 -721,8 +723,8 @@@ void ff_h264_filter_mb(const H264Contex
      const int mb_type = h->cur_pic.mb_type[mb_xy];
      const int mvy_limit = IS_INTERLACED(mb_type) ? 2 : 4;
      int first_vertical_edge_done = 0;
 -    int chroma = !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
 +    int chroma = CHROMA(h) && !(CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
-     int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
+     int qp_bd_offset = 6 * (h->ps.sps->bit_depth_luma - 8);
      int a = 52 + sl->slice_alpha_c0_offset - qp_bd_offset;
      int b = 52 + sl->slice_beta_offset - qp_bd_offset;
  
          /* First vertical edge is different in MBAFF frames
           * There are 8 different bS to compute and 2 different Qp
           */
 -        DECLARE_ALIGNED(8, int16_t, bS)[8];
 +        LOCAL_ALIGNED(8, int16_t, bS, [8]);
          int qp[2];
          int bqp[2];
          int rqp[2];
                      bS[i] = 4;
                  else{
                      bS[i] = 1 + !!(sl->non_zero_count_cache[12+8*(i>>1)] |
-                          ((!h->pps.cabac && IS_8x8DCT(mbn_type)) ?
+                          ((!h->ps.pps->cabac && IS_8x8DCT(mbn_type)) ?
                              (h->cbp_table[mbn_xy] & (((MB_FIELD(sl) ? (i&2) : (mb_y&1)) ? 8 : 2) << 12))
                                                                         :
                              h->non_zero_count[mbn_xy][ off[i] ]));
diff --combined libavcodec/h264_mb.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
   */
  
@@@ -39,17 -39,17 +39,17 @@@ static inline int get_lowest_part_list_
                                           int n, int height, int y_offset, int list)
  {
      int raw_my             = sl->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(const H264Context *h, H264SliceContext *sl,
 -                                     int refs[2][48], int n,
 +                                     int16_t refs[2][48], int n,
                                       int height, int y_offset, int list0,
                                       int list1, int *nrefs)
  {
@@@ -96,7 -96,7 +96,7 @@@ static void await_references(const H264
  {
      const int mb_xy   = sl->mb_xy;
      const int mb_type = h->cur_pic.mb_type[mb_xy];
 -    int refs[2][48];
 +    int16_t refs[2][48];
      int nrefs[2] = { 0 };
      int ref, list;
  
      } 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 = sl->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, sl, refs, n + j, 4, sub_y_offset,
                  nrefs[list]--;
  
                  if (!FIELD_PICTURE(h) && ref_field_picture) { // frame referencing two fields
 +                    av_assert2((ref_pic->parent->reference & 3) == 3);
                      ff_thread_await_progress(&ref_pic->parent->tf,
                                               FFMIN((row >> 1) - !(row & 1),
                                                     pic_height - 1),
@@@ -215,7 -214,7 +215,7 @@@ static av_always_inline void mc_dir_par
      const int mx      = sl->mv_cache[list][scan8[n]][0] + src_x_offset * 8;
      int my            = sl->mv_cache[list][scan8[n]][1] + src_y_offset * 8;
      const int luma_xy = (mx & 3) + ((my & 3) << 2);
 -    ptrdiff_t offset  = ((mx >> 2) << pixel_shift) + (my >> 2) * sl->mb_linesize;
 +    ptrdiff_t offset  = (mx >> 2) * (1 << pixel_shift) + (my >> 2) * sl->mb_linesize;
      uint8_t *src_y    = pic->data[0] + offset;
      uint8_t *src_cb, *src_cr;
      int extra_width  = 0;
          emu |= (my >> 3) < 0 || (my >> 3) + 8 >= (pic_height >> 1);
      }
  
 -    src_cb = pic->data[1] + ((mx >> 3) << pixel_shift) +
 +    src_cb = pic->data[1] + ((mx >> 3) * (1 << pixel_shift)) +
               (my >> ysh) * sl->mb_uvlinesize;
 -    src_cr = pic->data[2] + ((mx >> 3) << pixel_shift) +
 +    src_cr = pic->data[2] + ((mx >> 3) * (1 << pixel_shift)) +
               (my >> ysh) * sl->mb_uvlinesize;
  
      if (emu) {
      }
      chroma_op(dest_cb, src_cb, sl->mb_uvlinesize,
                height >> (chroma_idc == 1 /* yuv420 */),
 -              mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7);
 +              mx & 7, ((unsigned)my << (chroma_idc == 2 /* yuv422 */)) & 7);
  
      if (emu) {
          h->vdsp.emulated_edge_mc(sl->edge_emu_buffer, src_cr,
          src_cr = sl->edge_emu_buffer;
      }
      chroma_op(dest_cr, src_cr, sl->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */),
 -              mx & 7, (my << (chroma_idc == 2 /* yuv422 */)) & 7);
 +              mx & 7, ((unsigned)my << (chroma_idc == 2 /* yuv422 */)) & 7);
  }
  
  static av_always_inline void mc_part_std(const H264Context *h, H264SliceContext *sl,
@@@ -424,12 -423,10 +424,12 @@@ static av_always_inline void mc_part_we
              int weight1 = 64 - weight0;
              luma_weight_avg(dest_y, tmp_y, sl->mb_linesize,
                              height, 5, weight0, weight1, 0);
 -            chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize,
 -                              chroma_height, 5, weight0, weight1, 0);
 -            chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize,
 -                              chroma_height, 5, weight0, weight1, 0);
 +            if (!CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
 +                chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize,
 +                                  chroma_height, 5, weight0, weight1, 0);
 +                chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize,
 +                                  chroma_height, 5, weight0, weight1, 0);
 +            }
          } else {
              luma_weight_avg(dest_y, tmp_y, sl->mb_linesize, height,
                              sl->pwt.luma_log2_weight_denom,
                              sl->pwt.luma_weight[refn1][1][0],
                              sl->pwt.luma_weight[refn0][0][1] +
                              sl->pwt.luma_weight[refn1][1][1]);
 -            chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize, chroma_height,
 -                              sl->pwt.chroma_log2_weight_denom,
 -                              sl->pwt.chroma_weight[refn0][0][0][0],
 -                              sl->pwt.chroma_weight[refn1][1][0][0],
 -                              sl->pwt.chroma_weight[refn0][0][0][1] +
 -                              sl->pwt.chroma_weight[refn1][1][0][1]);
 -            chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize, chroma_height,
 -                              sl->pwt.chroma_log2_weight_denom,
 -                              sl->pwt.chroma_weight[refn0][0][1][0],
 -                              sl->pwt.chroma_weight[refn1][1][1][0],
 -                              sl->pwt.chroma_weight[refn0][0][1][1] +
 -                              sl->pwt.chroma_weight[refn1][1][1][1]);
 +            if (!CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
 +                chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize, chroma_height,
 +                                  sl->pwt.chroma_log2_weight_denom,
 +                                  sl->pwt.chroma_weight[refn0][0][0][0],
 +                                  sl->pwt.chroma_weight[refn1][1][0][0],
 +                                  sl->pwt.chroma_weight[refn0][0][0][1] +
 +                                  sl->pwt.chroma_weight[refn1][1][0][1]);
 +                chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize, chroma_height,
 +                                  sl->pwt.chroma_log2_weight_denom,
 +                                  sl->pwt.chroma_weight[refn0][0][1][0],
 +                                  sl->pwt.chroma_weight[refn1][1][1][0],
 +                                  sl->pwt.chroma_weight[refn0][0][1][1] +
 +                                  sl->pwt.chroma_weight[refn1][1][1][1]);
 +            }
          }
      } else {
          int list     = list1 ? 1 : 0;
                         sl->pwt.luma_log2_weight_denom,
                         sl->pwt.luma_weight[refn][list][0],
                         sl->pwt.luma_weight[refn][list][1]);
 -        if (sl->pwt.use_weight_chroma) {
 -            chroma_weight_op(dest_cb, sl->mb_uvlinesize, chroma_height,
 -                             sl->pwt.chroma_log2_weight_denom,
 -                             sl->pwt.chroma_weight[refn][list][0][0],
 -                             sl->pwt.chroma_weight[refn][list][0][1]);
 -            chroma_weight_op(dest_cr, sl->mb_uvlinesize, chroma_height,
 -                             sl->pwt.chroma_log2_weight_denom,
 -                             sl->pwt.chroma_weight[refn][list][1][0],
 -                             sl->pwt.chroma_weight[refn][list][1][1]);
 +        if (!CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
 +            if (sl->pwt.use_weight_chroma) {
 +                chroma_weight_op(dest_cb, sl->mb_uvlinesize, chroma_height,
 +                                 sl->pwt.chroma_log2_weight_denom,
 +                                 sl->pwt.chroma_weight[refn][list][0][0],
 +                                 sl->pwt.chroma_weight[refn][list][0][1]);
 +                chroma_weight_op(dest_cr, sl->mb_uvlinesize, chroma_height,
 +                                 sl->pwt.chroma_log2_weight_denom,
 +                                 sl->pwt.chroma_weight[refn][list][1][0],
 +                                 sl->pwt.chroma_weight[refn][list][1][1]);
 +            }
          }
      }
  }
@@@ -490,7 -483,7 +490,7 @@@ static av_always_inline void prefetch_m
          const int mx  = (sl->mv_cache[list][scan8[0]][0] >> 2) + 16 * sl->mb_x + 8;
          const int my  = (sl->mv_cache[list][scan8[0]][1] >> 2) + 16 * sl->mb_y;
          uint8_t **src = sl->ref_list[list][refn].data;
 -        int off       = (mx << pixel_shift) +
 +        int off       =  mx * (1<< pixel_shift) +
                          (my + (sl->mb_x & 3) * 4) * sl->mb_linesize +
                          (64 << pixel_shift);
          h->vdsp.prefetch(src[0] + off, sl->linesize, 4);
              h->vdsp.prefetch(src[1] + off, sl->linesize, 4);
              h->vdsp.prefetch(src[2] + off, sl->linesize, 4);
          } else {
 -            off = ((mx >> 1) << pixel_shift) +
 -                  ((my >> 1) + (sl->mb_x & 7)) * sl->uvlinesize +
 -                  (64 << pixel_shift);
 +            off= ((mx>>1)+64) * (1<<pixel_shift) + ((my>>1) + (sl->mb_x&7))*sl->uvlinesize;
              h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
          }
      }
@@@ -565,8 -560,10 +565,8 @@@ static av_always_inline void xchg_mb_bo
              XCHG(sl->top_borders[top_idx][sl->mb_x + 1],
                   src_y + (17 << pixel_shift), 1);
          }
 -    }
 -    if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
 -        if (chroma444) {
 -            if (deblock_top) {
 +        if (simple || !CONFIG_GRAY || !(h->flags & AV_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(sl->top_borders[top_idx][sl->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
                      XCHG(sl->top_borders[top_idx][sl->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);
@@@ -635,13 -634,8 +635,13 @@@ static av_always_inline void hl_decode_
              for (i = 0; i < 16; i += 4) {
                  uint8_t *const ptr = dest_y + block_offset[i];
                  const int dir      = sl->intra4x4_pred_mode_cache[scan8[i]];
-                 if (transform_bypass && h->sps.profile_idc == 244 && dir <= 1) {
+                 if (transform_bypass && h->ps.sps->profile_idc == 244 && dir <= 1) {
 -                    h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
 +                    if (h->x264_build != -1) {
 +                        h->hpc.pred8x8l_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
 +                    } else
 +                        h->hpc.pred8x8l_filter_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift),
 +                                                        (sl-> topleft_samples_available << i) & 0x8000,
 +                                                        (sl->topright_samples_available << i) & 0x4000, linesize);
                  } else {
                      const int nnz = sl->non_zero_count_cache[scan8[i + p * 16]];
                      h->hpc.pred8x8l[dir](ptr, (sl->topleft_samples_available << i) & 0x8000,
                  uint8_t *const ptr = dest_y + block_offset[i];
                  const int dir      = sl->intra4x4_pred_mode_cache[scan8[i]];
  
-                 if (transform_bypass && h->sps.profile_idc == 244 && dir <= 1) {
+                 if (transform_bypass && h->ps.sps->profile_idc == 244 && dir <= 1) {
                      h->hpc.pred4x4_add[dir](ptr, sl->mb + (i * 16 + p * 256 << pixel_shift), linesize);
                  } else {
                      uint8_t *topright;
                      uint64_t tr_high;
                      if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
                          const int topright_avail = (sl->topright_samples_available << i) & 0x8000;
 -                        assert(sl->mb_y || linesize <= block_offset[i]);
 +                        av_assert2(sl->mb_y || linesize <= block_offset[i]);
                          if (!topright_avail) {
                              if (pixel_shift) {
                                  tr_high  = ((uint16_t *)ptr)[3 - linesize / 2] * 0x0001000100010001ULL;
              if (!transform_bypass)
                  h->h264dsp.h264_luma_dc_dequant_idct(sl->mb + (p * 256 << pixel_shift),
                                                       sl->mb_luma_dc[p],
-                                                      h->dequant4_coeff[p][qscale][0]);
+                                                      h->ps.pps->dequant4_coeff[p][qscale][0]);
              else {
                  static const uint8_t dc_mapping[16] = {
                       0 * 16,  1 * 16,  4 * 16,  5 * 16,
@@@ -737,7 -731,7 +737,7 @@@ static av_always_inline void hl_decode_
      if (!IS_INTRA4x4(mb_type)) {
          if (IS_INTRA16x16(mb_type)) {
              if (transform_bypass) {
-                 if (h->sps.profile_idc == 244 &&
+                 if (h->ps.sps->profile_idc == 244 &&
                      (sl->intra16x16_pred_mode == VERT_PRED8x8 ||
                       sl->intra16x16_pred_mode == HOR_PRED8x8)) {
                      h->hpc.pred16x16_add[sl->intra16x16_pred_mode](dest_y, block_offset,
@@@ -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
   */
  
@@@ -48,7 -48,7 +48,7 @@@ static av_noinline void FUNC(hl_decode_
      int linesize, uvlinesize /*dct_offset*/;
      int i, j;
      const int *block_offset = &h->block_offset[0];
-     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->sps.transform_bypass);
+     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
      void (*idct_add)(uint8_t *dst, int16_t *block, int stride);
      const int block_h   = 16 >> h->chroma_y_shift;
      const int chroma422 = CHROMA422(h);
      }
  
      if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
-         const int bit_depth = h->sps.bit_depth_luma;
++        const int bit_depth = h->ps.sps->bit_depth_luma;
          if (PIXEL_SHIFT) {
 -            const int bit_depth = h->ps.sps->bit_depth_luma;
              int j;
              GetBitContext gb;
              init_get_bits(&gb, sl->intra_pcm_ptr,
-                           ff_h264_mb_sizes[h->sps.chroma_format_idc] * bit_depth);
+                           ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] * bit_depth);
  
              for (i = 0; i < 16; i++) {
                  uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
                      tmp_y[j] = get_bits(&gb, bit_depth);
              }
              if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
-                 if (!h->sps.chroma_format_idc) {
+                 if (!h->ps.sps->chroma_format_idc) {
                      for (i = 0; i < block_h; i++) {
                          uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
 -                        for (j = 0; j < 8; j++)
 -                            tmp_cb[j] = 1 << (bit_depth - 1);
 -                    }
 -                    for (i = 0; i < block_h; i++) {
                          uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
 -                        for (j = 0; j < 8; j++)
 -                            tmp_cr[j] = 1 << (bit_depth - 1);
 +                        for (j = 0; j < 8; j++) {
 +                            tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
 +                        }
                      }
                  } else {
                      for (i = 0; i < block_h; i++) {
              for (i = 0; i < 16; i++)
                  memcpy(dest_y + i * linesize, sl->intra_pcm_ptr + i * 16, 16);
              if (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
-                 if (!h->sps.chroma_format_idc) {
+                 if (!h->ps.sps->chroma_format_idc) {
 -                    for (i = 0; i < block_h; i++) {
 -                        memset(dest_cb + i * uvlinesize, 128, 8);
 -                        memset(dest_cr + i * uvlinesize, 128, 8);
 +                    for (i = 0; i < 8; i++) {
 +                        memset(dest_cb + i * uvlinesize, 1 << (bit_depth - 1), 8);
 +                        memset(dest_cr + i * uvlinesize, 1 << (bit_depth - 1), 8);
                      }
                  } else {
                      const uint8_t *src_cb = sl->intra_pcm_ptr + 256;
              (sl->cbp & 0x30)) {
              uint8_t *dest[2] = { dest_cb, dest_cr };
              if (transform_bypass) {
-                 if (IS_INTRA(mb_type) && h->sps.profile_idc == 244 &&
+                 if (IS_INTRA(mb_type) && h->ps.sps->profile_idc == 244 &&
                      (sl->chroma_pred_mode == VERT_PRED8x8 ||
                       sl->chroma_pred_mode == HOR_PRED8x8)) {
                      h->hpc.pred8x8_add[sl->chroma_pred_mode](dest[0],
                  }
                  if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 0]])
                      h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 1 << PIXEL_SHIFT),
-                                                            h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
+                                                            h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
                  if (sl->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 1]])
                      h->h264dsp.h264_chroma_dc_dequant_idct(sl->mb + (16 * 16 * 2 << PIXEL_SHIFT),
-                                                            h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
+                                                            h->ps.pps->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
                  h->h264dsp.h264_idct_add8(dest, block_offset,
                                            sl->mb, uvlinesize,
                                            sl->non_zero_count_cache);
@@@ -259,7 -262,7 +259,7 @@@ static av_noinline void FUNC(hl_decode_
      int linesize;
      int i, j, p;
      const int *block_offset = &h->block_offset[0];
-     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->sps.transform_bypass);
+     const int transform_bypass = !SIMPLE && (sl->qscale == 0 && h->ps.sps->transform_bypass);
      const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) ? 3 : 1;
  
      for (p = 0; p < plane_count; p++) {
  
      if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
          if (PIXEL_SHIFT) {
-             const int bit_depth = h->sps.bit_depth_luma;
+             const int bit_depth = h->ps.sps->bit_depth_luma;
              GetBitContext gb;
              init_get_bits(&gb, sl->intra_pcm_ptr, 768 * bit_depth);
  
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
   */
  
@@@ -32,8 -32,8 +32,8 @@@
  #include "avcodec.h"
  #include "h264.h"
  #include "mpegutils.h"
 +#include "libavutil/avassert.h"
  
 -#include <assert.h>
  
  static av_always_inline int fetch_diagonal_mv(const H264Context *h, H264SliceContext *sl,
                                                const int16_t **C,
@@@ -106,7 -106,7 +106,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
@@@ -464,7 -464,7 +464,7 @@@ static void fill_decode_caches(const H2
  
      if (!IS_SKIP(mb_type)) {
          if (IS_INTRA(mb_type)) {
-             int type_mask = h->pps.constrained_intra_pred ? IS_INTRA(-1) : -1;
+             int type_mask = h->ps.pps->constrained_intra_pred ? IS_INTRA(-1) : -1;
              sl->topleft_samples_available     =
                  sl->top_samples_available     =
                      sl->left_samples_available = 0xFFFF;
                  } 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))) {
                          sl->topleft_samples_available &= 0xDF5F;
                          sl->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) && !sl->direct_spatial_mv_pred));
 +            av_assert2(!(IS_DIRECT(mb_type) && !sl->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 +
                                        (sl->topleft_partition & 2 * b_stride);
  
  #define MAP_F2F(idx, mb_type)                                           \
      if (!IS_INTERLACED(mb_type) && sl->ref_cache[list][idx] >= 0) {     \
 -        sl->ref_cache[list][idx]    <<= 1;                              \
 +        sl->ref_cache[list][idx]     *= 2;                              \
          sl->mv_cache[list][idx][1]   /= 2;                              \
          sl->mvd_cache[list][idx][1] >>= 1;                              \
      }
  #define MAP_F2F(idx, mb_type)                                           \
      if (IS_INTERLACED(mb_type) && sl->ref_cache[list][idx] >= 0) {      \
          sl->ref_cache[list][idx]    >>= 1;                              \
 -        sl->mv_cache[list][idx][1]  <<= 1;                              \
 +        sl->mv_cache[list][idx][1]   *= 2;                              \
          sl->mvd_cache[list][idx][1] <<= 1;                              \
      }
  
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
   */
  
@@@ -25,8 -25,6 +25,8 @@@
   * @author Michael Niedermayer <michaelni@gmx.at>
   */
  
 +#define UNCHECKED_BITSTREAM_READER 1
 +
  #include <assert.h>
  #include <stdint.h>
  
@@@ -47,6 -45,7 +47,7 @@@
  typedef struct H264ParseContext {
      H264Context h;
      ParseContext pc;
+     H264ParamSets ps;
      int got_first;
  } H264ParseContext;
  
@@@ -55,36 -54,18 +56,36 @@@ static int h264_find_frame_end(H264Pars
                                 int buf_size)
  {
      H264Context *h = &p->h;
 -    int i;
 +    int i, j;
      uint32_t state;
      ParseContext *pc = &p->pc;
 +
 +    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.startcode_find_candidate(buf + i, buf_size - i);
 -            if (i < buf_size)
 +            i += h->h264dsp.startcode_find_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>5) {
 +                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);
 +                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 {
 -            // first_mb_in_slice is 0, probably the first nal of a new slice
 -            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) - 5 * (state > 7);
  }
  
  static int scan_mmco_reset(AVCodecParserContext *s, GetBitContext *gb)
      int list_count, ref_count[2];
  
  
-     if (h->pps.redundant_pic_cnt_present)
+     if (p->ps.pps->redundant_pic_cnt_present)
          get_ue_golomb(gb); // redundant_pic_count
  
      if (slice_type_nos == AV_PICTURE_TYPE_B)
          get_bits1(gb); // direct_spatial_mv_pred
  
-     if (ff_h264_parse_ref_count(&list_count, ref_count, gb, &h->pps,
+     if (ff_h264_parse_ref_count(&list_count, ref_count, gb, p->ps.pps,
 -                                slice_type_nos, h->picture_structure) < 0)
 +                                slice_type_nos, h->picture_structure, h->avctx) < 0)
          return AVERROR_INVALIDDATA;
  
      if (slice_type_nos != AV_PICTURE_TYPE_I) {
                      unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(gb);
  
                      if (reordering_of_pic_nums_idc < 3)
 -                        get_ue_golomb(gb);
 +                        get_ue_golomb_long(gb);
                      else if (reordering_of_pic_nums_idc > 3) {
                          av_log(h->avctx, AV_LOG_ERROR,
                                 "illegal reordering_of_pic_nums_idc %d\n",
          }
      }
  
-     if ((h->pps.weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
-         (h->pps.weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
-         ff_h264_pred_weight_table(gb, &h->sps, ref_count, slice_type_nos,
+     if ((p->ps.pps->weighted_pred && slice_type_nos == AV_PICTURE_TYPE_P) ||
+         (p->ps.pps->weighted_bipred_idc == 1 && slice_type_nos == AV_PICTURE_TYPE_B))
+         ff_h264_pred_weight_table(gb, p->ps.sps, ref_count, slice_type_nos,
                                    &pwt);
  
      if (get_bits1(gb)) { // adaptive_ref_pic_marking_mode_flag
                  return 1;
  
              if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
 -                get_ue_golomb(gb);
 +                get_ue_golomb_long(gb); // difference_of_pic_nums_minus1
              if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
                  opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
                  get_ue_golomb_31(gb);
   */
  static inline int parse_nal_units(AVCodecParserContext *s,
                                    AVCodecContext *avctx,
 -                                  const uint8_t *buf, int buf_size)
 +                                  const uint8_t * const buf, int buf_size)
  {
      H264ParseContext *p = s->priv_data;
      H264Context      *h = &p->h;
 -    const uint8_t *buf_end = buf + buf_size;
 -
      H2645NAL nal = { NULL };
 -
 +    int buf_index, next_avc;
      unsigned int pps_id;
      unsigned int slice_type;
      int state = -1, got_reset = 0;
 +    int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
      int field_poc[2];
      int ret;
  
  
      h->avctx = avctx;
      ff_h264_reset_sei(h);
 +    h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
  
      if (!buf_size)
          return 0;
  
 +    buf_index     = 0;
 +    next_avc      = h->is_avc ? 0 : buf_size;
      for (;;) {
 -        int src_length, consumed;
 -        buf = avpriv_find_start_code(buf, buf_end, &state);
 -        if (buf >= buf_end)
 -            break;
 -        --buf;
 -        src_length = buf_end - buf;
+         const SPS *sps;
 +        int src_length, consumed, nalsize = 0;
 +
 +        if (buf_index >= next_avc) {
 +            nalsize = get_avc_nalsize(h, buf, buf_size, &buf_index);
 +            if (nalsize < 0)
 +                break;
 +            next_avc = buf_index + nalsize;
 +        } else {
 +            buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
 +            if (buf_index >= buf_size)
 +                break;
 +            if (buf_index >= next_avc)
 +                continue;
 +        }
 +        src_length = next_avc - buf_index;
 +
 +        state = buf[buf_index];
          switch (state & 0x1f) {
          case NAL_SLICE:
          case NAL_IDR_SLICE:
              }
              break;
          }
 -
 -        consumed = ff_h2645_extract_rbsp(buf, src_length, &nal);
 +        consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &nal);
          if (consumed < 0)
              break;
  
 -        ret = init_get_bits(&nal.gb, nal.data, nal.size * 8);
 +        buf_index += consumed;
 +
 +        ret = init_get_bits8(&nal.gb, nal.data, nal.size);
          if (ret < 0)
              goto fail;
          get_bits1(&nal.gb);
  
          switch (h->nal_unit_type) {
          case NAL_SPS:
-             ff_h264_decode_seq_parameter_set(h, 0);
 -            ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps);
++            ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
              break;
          case NAL_PPS:
-             ff_h264_decode_picture_parameter_set(h, h->gb.size_in_bits);
+             ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
+                                                  nal.size_bits);
              break;
          case NAL_SEI:
--            ff_h264_decode_sei(h);
++            {
++                H264ParamSets ps = h->ps;
++                h->ps = p->ps;
++                ff_h264_decode_sei(h);
++                h->ps = ps;
++            }
              break;
          case NAL_IDR_SLICE:
              s->key_frame = 1;
              h->prev_poc_lsb          = 0;
          /* fall through */
          case NAL_SLICE:
 -            get_ue_golomb(&nal.gb);  // skip first_mb_in_slice
 +            get_ue_golomb_long(&nal.gb);  // skip first_mb_in_slice
              slice_type   = get_ue_golomb_31(&nal.gb);
              s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
              if (h->sei_recovery_frame_cnt >= 0) {
                         "pps_id %u out of range\n", pps_id);
                  goto fail;
              }
-             if (!h->pps_buffers[pps_id]) {
+             if (!p->ps.pps_list[pps_id]) {
                  av_log(h->avctx, AV_LOG_ERROR,
                         "non-existing PPS %u referenced\n", pps_id);
                  goto fail;
              }
-             h->pps = *h->pps_buffers[pps_id];
-             if (!h->sps_buffers[h->pps.sps_id]) {
+             p->ps.pps = (const PPS*)p->ps.pps_list[pps_id]->data;
+             if (!p->ps.sps_list[p->ps.pps->sps_id]) {
                  av_log(h->avctx, AV_LOG_ERROR,
-                        "non-existing SPS %u referenced\n", h->pps.sps_id);
+                        "non-existing SPS %u referenced\n", p->ps.pps->sps_id);
                  goto fail;
              }
-             h->sps       = *h->sps_buffers[h->pps.sps_id];
-             h->frame_num = get_bits(&nal.gb, h->sps.log2_max_frame_num);
+             p->ps.sps = (SPS*)p->ps.sps_list[p->ps.pps->sps_id]->data;
+             h->ps.sps = p->ps.sps;
+             h->ps.pps = p->ps.pps;
+             sps = p->ps.sps;
  
-             if(h->sps.ref_frame_count <= 1 && h->pps.ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
++            // heuristic to detect non marked keyframes
++            if (h->ps.sps->ref_frame_count <= 1 && h->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
 +                s->key_frame = 1;
 +
-             s->coded_width  = 16 * h->sps.mb_width;
-             s->coded_height = 16 * h->sps.mb_height;
-             s->width        = s->coded_width  - (h->sps.crop_right + h->sps.crop_left);
-             s->height       = s->coded_height - (h->sps.crop_top   + h->sps.crop_bottom);
+             h->frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
+             s->coded_width  = 16 * sps->mb_width;
+             s->coded_height = 16 * sps->mb_height;
+             s->width        = s->coded_width  - (sps->crop_right + sps->crop_left);
+             s->height       = s->coded_height - (sps->crop_top   + sps->crop_bottom);
              if (s->width <= 0 || s->height <= 0) {
                  s->width  = s->coded_width;
                  s->height = s->coded_height;
              }
  
-             switch (h->sps.bit_depth_luma) {
+             switch (sps->bit_depth_luma) {
              case 9:
                  if (CHROMA444(h))      s->format = AV_PIX_FMT_YUV444P9;
                  else if (CHROMA422(h)) s->format = AV_PIX_FMT_YUV422P9;
                  s->format = AV_PIX_FMT_NONE;
              }
  
-             avctx->profile = ff_h264_get_profile(&h->sps);
-             avctx->level   = h->sps.level_idc;
+             avctx->profile = ff_h264_get_profile(sps);
+             avctx->level   = sps->level_idc;
  
-             if (h->sps.frame_mbs_only_flag) {
+             if (sps->frame_mbs_only_flag) {
                  h->picture_structure = PICT_FRAME;
              } else {
                  if (get_bits1(&nal.gb)) { // field_pic_flag
              }
  
              if (h->nal_unit_type == NAL_IDR_SLICE)
 -                get_ue_golomb(&nal.gb); /* idr_pic_id */
 +                get_ue_golomb_long(&nal.gb); /* idr_pic_id */
-             if (h->sps.poc_type == 0) {
-                 h->poc_lsb = get_bits(&nal.gb, h->sps.log2_max_poc_lsb);
+             if (sps->poc_type == 0) {
+                 h->poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
  
-                 if (h->pps.pic_order_present == 1 &&
+                 if (p->ps.pps->pic_order_present == 1 &&
                      h->picture_structure == PICT_FRAME)
                      h->delta_poc_bottom = get_se_golomb(&nal.gb);
              }
  
-             if (h->sps.poc_type == 1 &&
-                 !h->sps.delta_pic_order_always_zero_flag) {
+             if (sps->poc_type == 1 &&
+                 !sps->delta_pic_order_always_zero_flag) {
                  h->delta_poc[0] = get_se_golomb(&nal.gb);
  
-                 if (h->pps.pic_order_present == 1 &&
+                 if (p->ps.pps->pic_order_present == 1 &&
                      h->picture_structure == PICT_FRAME)
                      h->delta_poc[1] = get_se_golomb(&nal.gb);
              }
                  }
              }
  
-             if (h->sps.pic_struct_present_flag) {
+             if (sps->pic_struct_present_flag) {
                  switch (h->sei_pic_struct) {
                  case SEI_PIC_STRUCT_TOP_FIELD:
                  case SEI_PIC_STRUCT_BOTTOM_FIELD:
  
              if (h->picture_structure == PICT_FRAME) {
                  s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
-                 if (h->sps.pic_struct_present_flag) {
+                 if (sps->pic_struct_present_flag) {
                      switch (h->sei_pic_struct) {
                      case SEI_PIC_STRUCT_TOP_BOTTOM:
                      case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
              av_freep(&nal.rbsp_buffer);
              return 0; /* no need to evaluate the rest */
          }
 -        buf += consumed;
 +    }
 +    if (q264) {
 +        av_freep(&nal.rbsp_buffer);
 +        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);
  fail:
      av_freep(&nal.rbsp_buffer);
      return -1;
@@@ -533,14 -488,15 +547,35 @@@ static int h264_parse(AVCodecParserCont
      if (!p->got_first) {
          p->got_first = 1;
          if (avctx->extradata_size) {
++            int i;
++
              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);
++
++            for (i = 0; i < FF_ARRAY_ELEMS(p->ps.sps_list); i++) {
++                av_buffer_unref(&p->ps.sps_list[i]);
++                if (h->ps.sps_list[i]) {
++                    p->ps.sps_list[i] = av_buffer_ref(h->ps.sps_list[i]);
++                    if (!p->ps.sps_list[i])
++                        return AVERROR(ENOMEM);
++                }
++            }
++            for (i = 0; i < FF_ARRAY_ELEMS(p->ps.pps_list); i++) {
++                av_buffer_unref(&p->ps.pps_list[i]);
++                if (h->ps.pps_list[i]) {
++                    p->ps.pps_list[i] = av_buffer_ref(h->ps.pps_list[i]);
++                    if (!p->ps.pps_list[i])
++                        return AVERROR(ENOMEM);
++                }
++            }
++
++            p->ps.sps = h->ps.sps;
          }
      }
  
          }
  
          if (next < 0 && next != END_NOT_FOUND) {
 -            assert(pc->last_index + next >= 0);
 +            av_assert1(pc->last_index + next >= 0);
              h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next); // update state
          }
      }
  
      parse_nal_units(s, avctx, buf, buf_size);
  
 +    if (avctx->framerate.num)
 +        avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
      if (h->sei_cpb_removal_delay >= 0) {
          s->dts_sync_point    = h->sei_buffering_period_present;
          s->dts_ref_dts_delta = h->sei_cpb_removal_delay;
  static int h264_split(AVCodecContext *avctx,
                        const uint8_t *buf, int buf_size)
  {
 -    int i;
      uint32_t state = -1;
      int has_sps    = 0;
 +    int has_pps    = 0;
 +    const uint8_t *ptr = buf, *end = buf + buf_size;
 +    int nalu_type;
  
 -    for (i = 0; i <= buf_size; i++) {
 -        if ((state & 0xFFFFFF1F) == 0x107)
 +    while (ptr < end) {
 +        ptr = avpriv_find_start_code(ptr, end, &state);
 +        if ((state & 0xFFFFFF00) != 0x100)
 +            break;
 +        nalu_type = state & 0x1F;
 +        if (nalu_type == NAL_SPS) {
              has_sps = 1;
 -        /*  if((state&0xFFFFFF1F) == 0x101 ||
 -         *     (state&0xFFFFFF1F) == 0x102 ||
 -         *     (state&0xFFFFFF1F) == 0x105) {
 +        } else if (nalu_type == NAL_PPS)
 +            has_pps = 1;
 +        /* else if (nalu_type == 0x01 ||
 +         *     nalu_type == 0x02 ||
 +         *     nalu_type == 0x05) {
           *  }
           */
 -        if ((state & 0xFFFFFF00) == 0x100 && (state & 0xFFFFFF1F) != 0x106 &&
 -            (state & 0xFFFFFF1F) != 0x107 && (state & 0xFFFFFF1F) != 0x108 &&
 -            (state & 0xFFFFFF1F) != 0x109 && (state & 0xFFFFFF1F) != 0x10d &&
 -            (state & 0xFFFFFF1F) != 0x10f) {
 +        else if ((nalu_type != NAL_SEI || has_pps) &&
 +                  nalu_type != NAL_AUD && nalu_type != NAL_SPS_EXT &&
 +                  nalu_type != 0x0f) {
              if (has_sps) {
 -                while (i > 4 && buf[i - 5] == 0)
 -                    i--;
 -                return i - 4;
 +                while (ptr - 4 > buf && ptr[-5] == 0)
 +                    ptr--;
 +                return ptr - 4 - buf;
              }
          }
 -        if (i < buf_size)
 -            state = (state << 8) | buf[i];
      }
 +
      return 0;
  }
  
@@@ -626,9 -574,16 +661,16 @@@ static void h264_close(AVCodecParserCon
      H264ParseContext *p = s->priv_data;
      H264Context      *h = &p->h;
      ParseContext *pc = &p->pc;
+     int i;
  
 -    av_free(pc->buffer);
 +    av_freep(&pc->buffer);
      ff_h264_free_context(h);
+     for (i = 0; i < FF_ARRAY_ELEMS(p->ps.sps_list); i++)
+         av_buffer_unref(&p->ps.sps_list[i]);
+     for (i = 0; i < FF_ARRAY_ELEMS(p->ps.pps_list); i++)
+         av_buffer_unref(&p->ps.pps_list[i]);
  }
  
  static av_cold int init(AVCodecParserContext *s)
diff --combined libavcodec/h264_ps.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... parameter set 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 MAX_LOG2_MAX_FRAME_NUM    (12 + 4)
  #define MIN_LOG2_MAX_FRAME_NUM    4
  
 -static const AVRational pixel_aspect[17] = {
 -    {   0,  1 },
 -    {   1,  1 },
 -    {  12, 11 },
 -    {  10, 11 },
 -    {  16, 11 },
 -    {  40, 33 },
 -    {  24, 11 },
 -    {  20, 11 },
 -    {  32, 11 },
 -    {  80, 33 },
 -    {  18, 11 },
 -    {  15, 11 },
 -    {  64, 33 },
 -    { 160, 99 },
 -    {   4,  3 },
 -    {   3,  2 },
 -    {   2,  1 },
 -};
 -
  static const uint8_t default_scaling4[2][16] = {
      {  6, 13, 20, 28, 13, 20, 28, 32,
        20, 28, 32, 37, 28, 32, 37, 42 },
@@@ -84,47 -104,71 +84,68 @@@ static const int level_max_dpb_mbs[][2
      { 52, 184320    },
  };
  
- static inline int decode_hrd_parameters(H264Context *h, SPS *sps)
+ static void remove_pps(H264ParamSets *s, int id)
+ {
 -    if (s->pps_list[id] && s->pps == (const PPS*)s->pps_list[id]->data)
 -        s->pps = NULL;
+     av_buffer_unref(&s->pps_list[id]);
+ }
+ static void remove_sps(H264ParamSets *s, int id)
+ {
++#if 0
+     int i;
+     if (s->sps_list[id]) {
 -        if (s->sps == (SPS*)s->sps_list[id]->data)
 -            s->sps = NULL;
 -
+         /* drop all PPS that depend on this SPS */
+         for (i = 0; i < FF_ARRAY_ELEMS(s->pps_list); i++)
+             if (s->pps_list[i] && ((PPS*)s->pps_list[i]->data)->sps_id == id)
+                 remove_pps(s, i);
+     }
++#endif
+     av_buffer_unref(&s->sps_list[id]);
+ }
+ static inline int decode_hrd_parameters(GetBitContext *gb, AVCodecContext *avctx,
+                                         SPS *sps)
  {
      int cpb_count, i;
-     cpb_count = get_ue_golomb_31(&h->gb) + 1;
+     cpb_count = get_ue_golomb_31(gb) + 1;
  
      if (cpb_count > 32U) {
-         av_log(h->avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
+         av_log(avctx, AV_LOG_ERROR, "cpb_count %d invalid\n", cpb_count);
          return AVERROR_INVALIDDATA;
      }
  
-     get_bits(&h->gb, 4); /* bit_rate_scale */
-     get_bits(&h->gb, 4); /* cpb_size_scale */
+     get_bits(gb, 4); /* bit_rate_scale */
+     get_bits(gb, 4); /* cpb_size_scale */
      for (i = 0; i < cpb_count; i++) {
-         get_ue_golomb_long(&h->gb); /* bit_rate_value_minus1 */
-         get_ue_golomb_long(&h->gb); /* cpb_size_value_minus1 */
-         get_bits1(&h->gb);          /* cbr_flag */
-     }
-     sps->initial_cpb_removal_delay_length = get_bits(&h->gb, 5) + 1;
-     sps->cpb_removal_delay_length         = get_bits(&h->gb, 5) + 1;
-     sps->dpb_output_delay_length          = get_bits(&h->gb, 5) + 1;
-     sps->time_offset_length               = get_bits(&h->gb, 5);
+         get_ue_golomb_long(gb); /* bit_rate_value_minus1 */
+         get_ue_golomb_long(gb); /* cpb_size_value_minus1 */
+         get_bits1(gb);          /* cbr_flag */
+     }
+     sps->initial_cpb_removal_delay_length = get_bits(gb, 5) + 1;
+     sps->cpb_removal_delay_length         = get_bits(gb, 5) + 1;
+     sps->dpb_output_delay_length          = get_bits(gb, 5) + 1;
+     sps->time_offset_length               = get_bits(gb, 5);
      sps->cpb_cnt                          = cpb_count;
      return 0;
  }
  
- static inline int decode_vui_parameters(H264Context *h, SPS *sps)
+ static inline int decode_vui_parameters(GetBitContext *gb, AVCodecContext *avctx,
+                                         SPS *sps)
  {
      int aspect_ratio_info_present_flag;
      unsigned int aspect_ratio_idc;
  
-     aspect_ratio_info_present_flag = get_bits1(&h->gb);
+     aspect_ratio_info_present_flag = get_bits1(gb);
  
      if (aspect_ratio_info_present_flag) {
-         aspect_ratio_idc = get_bits(&h->gb, 8);
+         aspect_ratio_idc = get_bits(gb, 8);
          if (aspect_ratio_idc == EXTENDED_SAR) {
-             sps->sar.num = get_bits(&h->gb, 16);
-             sps->sar.den = get_bits(&h->gb, 16);
+             sps->sar.num = get_bits(gb, 16);
+             sps->sar.den = get_bits(gb, 16);
 -        } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(pixel_aspect)) {
 -            sps->sar = pixel_aspect[aspect_ratio_idc];
 +        } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(ff_h264_pixel_aspect)) {
 +            sps->sar = ff_h264_pixel_aspect[aspect_ratio_idc];
          } else {
-             av_log(h->avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
+             av_log(avctx, AV_LOG_ERROR, "illegal aspect ratio\n");
              return AVERROR_INVALIDDATA;
          }
      } else {
          sps->sar.den = 0;
      }
  
-     if (get_bits1(&h->gb))      /* overscan_info_present_flag */
-         get_bits1(&h->gb);      /* overscan_appropriate_flag */
+     if (get_bits1(gb))      /* overscan_info_present_flag */
+         get_bits1(gb);      /* overscan_appropriate_flag */
  
-     sps->video_signal_type_present_flag = get_bits1(&h->gb);
+     sps->video_signal_type_present_flag = get_bits1(gb);
      if (sps->video_signal_type_present_flag) {
-         get_bits(&h->gb, 3);                 /* video_format */
-         sps->full_range = get_bits1(&h->gb); /* video_full_range_flag */
+         get_bits(gb, 3);                 /* video_format */
+         sps->full_range = get_bits1(gb); /* video_full_range_flag */
  
-         sps->colour_description_present_flag = get_bits1(&h->gb);
+         sps->colour_description_present_flag = get_bits1(gb);
          if (sps->colour_description_present_flag) {
-             sps->color_primaries = get_bits(&h->gb, 8); /* colour_primaries */
-             sps->color_trc       = get_bits(&h->gb, 8); /* transfer_characteristics */
-             sps->colorspace      = get_bits(&h->gb, 8); /* matrix_coefficients */
+             sps->color_primaries = get_bits(gb, 8); /* colour_primaries */
+             sps->color_trc       = get_bits(gb, 8); /* transfer_characteristics */
+             sps->colorspace      = get_bits(gb, 8); /* matrix_coefficients */
              if (sps->color_primaries >= AVCOL_PRI_NB)
                  sps->color_primaries = AVCOL_PRI_UNSPECIFIED;
              if (sps->color_trc >= AVCOL_TRC_NB)
      }
  
      /* chroma_location_info_present_flag */
-     if (get_bits1(&h->gb)) {
+     if (get_bits1(gb)) {
          /* chroma_sample_location_type_top_field */
-         h->avctx->chroma_sample_location = get_ue_golomb(&h->gb) + 1;
-         get_ue_golomb(&h->gb);  /* chroma_sample_location_type_bottom_field */
+         avctx->chroma_sample_location = get_ue_golomb(gb) + 1;
+         get_ue_golomb(gb);  /* chroma_sample_location_type_bottom_field */
      }
  
-     if (show_bits1(&h->gb) && get_bits_left(&h->gb) < 10) {
-         av_log(h->avctx, AV_LOG_WARNING, "Truncated VUI\n");
++    if (show_bits1(gb) && get_bits_left(gb) < 10) {
++        av_log(avctx, AV_LOG_WARNING, "Truncated VUI\n");
 +        return 0;
 +    }
 +
-     sps->timing_info_present_flag = get_bits1(&h->gb);
+     sps->timing_info_present_flag = get_bits1(gb);
      if (sps->timing_info_present_flag) {
-         unsigned num_units_in_tick = get_bits_long(&h->gb, 32);
-         unsigned time_scale        = get_bits_long(&h->gb, 32);
 -        sps->num_units_in_tick = get_bits_long(gb, 32);
 -        sps->time_scale        = get_bits_long(gb, 32);
 -        if (!sps->num_units_in_tick || !sps->time_scale) {
++        unsigned num_units_in_tick = get_bits_long(gb, 32);
++        unsigned time_scale        = get_bits_long(gb, 32);
 +        if (!num_units_in_tick || !time_scale) {
-             av_log(h->avctx, AV_LOG_ERROR,
+             av_log(avctx, AV_LOG_ERROR,
 -                   "time_scale/num_units_in_tick invalid or unsupported (%"PRIu32"/%"PRIu32")\n",
 -                   sps->time_scale, sps->num_units_in_tick);
 -            return AVERROR_INVALIDDATA;
 +                   "time_scale/num_units_in_tick invalid or unsupported (%u/%u)\n",
 +                   time_scale, num_units_in_tick);
 +            sps->timing_info_present_flag = 0;
 +        } else {
 +            sps->num_units_in_tick = num_units_in_tick;
 +            sps->time_scale = time_scale;
          }
-         sps->fixed_frame_rate_flag = get_bits1(&h->gb);
+         sps->fixed_frame_rate_flag = get_bits1(gb);
      }
  
-     sps->nal_hrd_parameters_present_flag = get_bits1(&h->gb);
+     sps->nal_hrd_parameters_present_flag = get_bits1(gb);
      if (sps->nal_hrd_parameters_present_flag)
-         if (decode_hrd_parameters(h, sps) < 0)
+         if (decode_hrd_parameters(gb, avctx, sps) < 0)
              return AVERROR_INVALIDDATA;
-     sps->vcl_hrd_parameters_present_flag = get_bits1(&h->gb);
+     sps->vcl_hrd_parameters_present_flag = get_bits1(gb);
      if (sps->vcl_hrd_parameters_present_flag)
-         if (decode_hrd_parameters(h, sps) < 0)
+         if (decode_hrd_parameters(gb, avctx, sps) < 0)
              return AVERROR_INVALIDDATA;
      if (sps->nal_hrd_parameters_present_flag ||
          sps->vcl_hrd_parameters_present_flag)
-         get_bits1(&h->gb);     /* low_delay_hrd_flag */
-     sps->pic_struct_present_flag = get_bits1(&h->gb);
-     if (!get_bits_left(&h->gb))
+         get_bits1(gb);     /* low_delay_hrd_flag */
+     sps->pic_struct_present_flag = get_bits1(gb);
 -
++    if (!get_bits_left(gb))
 +        return 0;
-     sps->bitstream_restriction_flag = get_bits1(&h->gb);
+     sps->bitstream_restriction_flag = get_bits1(gb);
      if (sps->bitstream_restriction_flag) {
-         get_bits1(&h->gb);     /* motion_vectors_over_pic_boundaries_flag */
-         get_ue_golomb(&h->gb); /* max_bytes_per_pic_denom */
-         get_ue_golomb(&h->gb); /* max_bits_per_mb_denom */
-         get_ue_golomb(&h->gb); /* log2_max_mv_length_horizontal */
-         get_ue_golomb(&h->gb); /* log2_max_mv_length_vertical */
-         sps->num_reorder_frames = get_ue_golomb(&h->gb);
-         get_ue_golomb(&h->gb); /*max_dec_frame_buffering*/
-         if (get_bits_left(&h->gb) < 0) {
+         get_bits1(gb);     /* motion_vectors_over_pic_boundaries_flag */
+         get_ue_golomb(gb); /* max_bytes_per_pic_denom */
+         get_ue_golomb(gb); /* max_bits_per_mb_denom */
+         get_ue_golomb(gb); /* log2_max_mv_length_horizontal */
+         get_ue_golomb(gb); /* log2_max_mv_length_vertical */
+         sps->num_reorder_frames = get_ue_golomb(gb);
+         get_ue_golomb(gb); /*max_dec_frame_buffering*/
+         if (get_bits_left(gb) < 0) {
              sps->num_reorder_frames         = 0;
              sps->bitstream_restriction_flag = 0;
          }
  
          if (sps->num_reorder_frames > 16U
              /* max_dec_frame_buffering || max_dec_frame_buffering > 16 */) {
-             av_log(h->avctx, AV_LOG_ERROR,
+             av_log(avctx, AV_LOG_ERROR,
                     "Clipping illegal num_reorder_frames %d\n",
                     sps->num_reorder_frames);
              sps->num_reorder_frames = 16;
              return AVERROR_INVALIDDATA;
          }
      }
 -    if (get_bits_left(gb) < 0) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Overread VUI by %d bits\n", -get_bits_left(gb));
 -        return AVERROR_INVALIDDATA;
 -    }
  
      return 0;
  }
  
- static void decode_scaling_list(H264Context *h, uint8_t *factors, int size,
+ static void decode_scaling_list(GetBitContext *gb, uint8_t *factors, int size,
                                  const uint8_t *jvt_list,
                                  const uint8_t *fallback_list)
  {
      int i, last = 8, next = 8;
      const uint8_t *scan = size == 16 ? ff_zigzag_scan : ff_zigzag_direct;
-     if (!get_bits1(&h->gb)) /* matrix not written, we use the predicted one */
+     if (!get_bits1(gb)) /* matrix not written, we use the predicted one */
          memcpy(factors, fallback_list, size * sizeof(uint8_t));
      else
          for (i = 0; i < size; i++) {
              if (next)
-                 next = (last + get_se_golomb(&h->gb)) & 0xff;
+                 next = (last + get_se_golomb(gb)) & 0xff;
              if (!i && !next) { /* matrix not written, we use the preset one */
                  memcpy(factors, jvt_list, size * sizeof(uint8_t));
                  break;
          }
  }
  
- static void decode_scaling_matrices(H264Context *h, SPS *sps,
+ static void decode_scaling_matrices(GetBitContext *gb, SPS *sps,
                                      PPS *pps, int is_sps,
                                      uint8_t(*scaling_matrix4)[16],
                                      uint8_t(*scaling_matrix8)[64])
          fallback_sps ? sps->scaling_matrix8[0] : default_scaling8[0],
          fallback_sps ? sps->scaling_matrix8[3] : default_scaling8[1]
      };
-     if (get_bits1(&h->gb)) {
+     if (get_bits1(gb)) {
          sps->scaling_matrix_present |= is_sps;
-         decode_scaling_list(h, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
-         decode_scaling_list(h, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
-         decode_scaling_list(h, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
-         decode_scaling_list(h, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
-         decode_scaling_list(h, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
-         decode_scaling_list(h, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
+         decode_scaling_list(gb, scaling_matrix4[0], 16, default_scaling4[0], fallback[0]);        // Intra, Y
+         decode_scaling_list(gb, scaling_matrix4[1], 16, default_scaling4[0], scaling_matrix4[0]); // Intra, Cr
+         decode_scaling_list(gb, scaling_matrix4[2], 16, default_scaling4[0], scaling_matrix4[1]); // Intra, Cb
+         decode_scaling_list(gb, scaling_matrix4[3], 16, default_scaling4[1], fallback[1]);        // Inter, Y
+         decode_scaling_list(gb, scaling_matrix4[4], 16, default_scaling4[1], scaling_matrix4[3]); // Inter, Cr
+         decode_scaling_list(gb, scaling_matrix4[5], 16, default_scaling4[1], scaling_matrix4[4]); // Inter, Cb
          if (is_sps || pps->transform_8x8_mode) {
-             decode_scaling_list(h, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
-             decode_scaling_list(h, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
+             decode_scaling_list(gb, scaling_matrix8[0], 64, default_scaling8[0], fallback[2]); // Intra, Y
 -            if (sps->chroma_format_idc == 3) {
 -                decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
 -                decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
 -            }
+             decode_scaling_list(gb, scaling_matrix8[3], 64, default_scaling8[1], fallback[3]); // Inter, Y
              if (sps->chroma_format_idc == 3) {
-                 decode_scaling_list(h, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
-                 decode_scaling_list(h, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
-                 decode_scaling_list(h, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
-                 decode_scaling_list(h, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
++                decode_scaling_list(gb, scaling_matrix8[1], 64, default_scaling8[0], scaling_matrix8[0]); // Intra, Cr
+                 decode_scaling_list(gb, scaling_matrix8[4], 64, default_scaling8[1], scaling_matrix8[3]); // Inter, Cr
++                decode_scaling_list(gb, scaling_matrix8[2], 64, default_scaling8[0], scaling_matrix8[1]); // Intra, Cb
+                 decode_scaling_list(gb, scaling_matrix8[5], 64, default_scaling8[1], scaling_matrix8[4]); // Inter, Cb
              }
          }
      }
  }
  
- int ff_h264_decode_seq_parameter_set(H264Context *h, int ignore_truncation)
+ int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
 -                                     H264ParamSets *ps)
++                                     H264ParamSets *ps, int ignore_truncation)
  {
+     AVBufferRef *sps_buf;
      int profile_idc, level_idc, constraint_set_flags = 0;
      unsigned int sps_id;
      int i, log2_max_frame_num_minus4;
      SPS *sps;
  
-     sps = av_mallocz(sizeof(SPS));
-     if (!sps)
++    sps_buf = av_buffer_allocz(sizeof(*sps));
++    if (!sps_buf)
 +        return AVERROR(ENOMEM);
++    sps = (SPS*)sps_buf->data;
 +
-     sps->data_size = h->gb.buffer_end - h->gb.buffer;
++    sps->data_size = gb->buffer_end - gb->buffer;
 +    if (sps->data_size > sizeof(sps->data)) {
-         av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
++        av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized SPS\n");
 +        sps->data_size = sizeof(sps->data);
 +    }
-     memcpy(sps->data, h->gb.buffer, sps->data_size);
-     profile_idc           = get_bits(&h->gb, 8);
-     constraint_set_flags |= get_bits1(&h->gb) << 0;   // constraint_set0_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 1;   // constraint_set1_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 2;   // constraint_set2_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 3;   // constraint_set3_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 4;   // constraint_set4_flag
-     constraint_set_flags |= get_bits1(&h->gb) << 5;   // constraint_set5_flag
-     skip_bits(&h->gb, 2);                             // reserved_zero_2bits
-     level_idc = get_bits(&h->gb, 8);
-     sps_id    = get_ue_golomb_31(&h->gb);
++    memcpy(sps->data, gb->buffer, sps->data_size);
++
+     profile_idc           = get_bits(gb, 8);
+     constraint_set_flags |= get_bits1(gb) << 0;   // constraint_set0_flag
+     constraint_set_flags |= get_bits1(gb) << 1;   // constraint_set1_flag
+     constraint_set_flags |= get_bits1(gb) << 2;   // constraint_set2_flag
+     constraint_set_flags |= get_bits1(gb) << 3;   // constraint_set3_flag
+     constraint_set_flags |= get_bits1(gb) << 4;   // constraint_set4_flag
+     constraint_set_flags |= get_bits1(gb) << 5;   // constraint_set5_flag
+     skip_bits(gb, 2);                             // reserved_zero_2bits
+     level_idc = get_bits(gb, 8);
+     sps_id    = get_ue_golomb_31(gb);
  
      if (sps_id >= MAX_SPS_COUNT) {
-         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
+         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", sps_id);
 -        return AVERROR_INVALIDDATA;
 +        goto fail;
      }
  
 -    sps_buf = av_buffer_allocz(sizeof(*sps));
 -    if (!sps_buf)
 -        return AVERROR(ENOMEM);
 -    sps = (SPS*)sps_buf->data;
 -
      sps->sps_id               = sps_id;
      sps->time_offset_length   = 24;
      sps->profile_idc          = profile_idc;
      sps->constraint_set_flags = constraint_set_flags;
      sps->level_idc            = level_idc;
 +    sps->full_range           = -1;
  
      memset(sps->scaling_matrix4, 16, sizeof(sps->scaling_matrix4));
      memset(sps->scaling_matrix8, 16, sizeof(sps->scaling_matrix8));
      sps->scaling_matrix_present = 0;
 +    sps->colorspace = 2; //AVCOL_SPC_UNSPECIFIED
  
      if (sps->profile_idc == 100 ||  // High profile
          sps->profile_idc == 110 ||  // High10 profile
          sps->profile_idc == 128 ||  // Multiview High profile (MVC)
          sps->profile_idc == 138 ||  // Multiview Depth High profile (MVCD)
          sps->profile_idc == 144) {  // old High444 profile
-         sps->chroma_format_idc = get_ue_golomb_31(&h->gb);
+         sps->chroma_format_idc = get_ue_golomb_31(gb);
 -        if (sps->chroma_format_idc > 3) {
 +        if (sps->chroma_format_idc > 3U) {
-             avpriv_request_sample(h->avctx, "chroma_format_idc %u",
+             avpriv_request_sample(avctx, "chroma_format_idc %u",
                                    sps->chroma_format_idc);
              goto fail;
          } else if (sps->chroma_format_idc == 3) {
-             sps->residual_color_transform_flag = get_bits1(&h->gb);
+             sps->residual_color_transform_flag = get_bits1(gb);
 +            if (sps->residual_color_transform_flag) {
-                 av_log(h->avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
++                av_log(avctx, AV_LOG_ERROR, "separate color planes are not supported\n");
 +                goto fail;
 +            }
          }
-         sps->bit_depth_luma   = get_ue_golomb(&h->gb) + 8;
-         sps->bit_depth_chroma = get_ue_golomb(&h->gb) + 8;
+         sps->bit_depth_luma   = get_ue_golomb(gb) + 8;
+         sps->bit_depth_chroma = get_ue_golomb(gb) + 8;
          if (sps->bit_depth_chroma != sps->bit_depth_luma) {
-             avpriv_request_sample(h->avctx,
+             avpriv_request_sample(avctx,
                                    "Different chroma and luma bit depth");
              goto fail;
          }
-             av_log(h->avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 +        if (sps->bit_depth_luma   < 8 || sps->bit_depth_luma   > 14 ||
 +            sps->bit_depth_chroma < 8 || sps->bit_depth_chroma > 14) {
-         sps->transform_bypass = get_bits1(&h->gb);
-         decode_scaling_matrices(h, sps, NULL, 1,
++            av_log(avctx, AV_LOG_ERROR, "illegal bit depth value (%d, %d)\n",
 +                   sps->bit_depth_luma, sps->bit_depth_chroma);
 +            goto fail;
 +        }
+         sps->transform_bypass = get_bits1(gb);
+         decode_scaling_matrices(gb, sps, NULL, 1,
                                  sps->scaling_matrix4, sps->scaling_matrix8);
      } else {
          sps->chroma_format_idc = 1;
          sps->bit_depth_chroma  = 8;
      }
  
-     log2_max_frame_num_minus4 = get_ue_golomb(&h->gb);
+     log2_max_frame_num_minus4 = get_ue_golomb(gb);
      if (log2_max_frame_num_minus4 < MIN_LOG2_MAX_FRAME_NUM - 4 ||
          log2_max_frame_num_minus4 > MAX_LOG2_MAX_FRAME_NUM - 4) {
-         av_log(h->avctx, AV_LOG_ERROR,
+         av_log(avctx, AV_LOG_ERROR,
                 "log2_max_frame_num_minus4 out of range (0-12): %d\n",
                 log2_max_frame_num_minus4);
          goto fail;
      }
      sps->log2_max_frame_num = log2_max_frame_num_minus4 + 4;
  
-     sps->poc_type = get_ue_golomb_31(&h->gb);
+     sps->poc_type = get_ue_golomb_31(gb);
  
      if (sps->poc_type == 0) { // FIXME #define
-         unsigned t = get_ue_golomb(&h->gb);
 -        sps->log2_max_poc_lsb = get_ue_golomb(gb) + 4;
++        unsigned t = get_ue_golomb(gb);
 +        if (t>12) {
-             av_log(h->avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
++            av_log(avctx, AV_LOG_ERROR, "log2_max_poc_lsb (%d) is out of range\n", t);
 +            goto fail;
 +        }
 +        sps->log2_max_poc_lsb = t + 4;
      } else if (sps->poc_type == 1) { // FIXME #define
-         sps->delta_pic_order_always_zero_flag = get_bits1(&h->gb);
-         sps->offset_for_non_ref_pic           = get_se_golomb(&h->gb);
-         sps->offset_for_top_to_bottom_field   = get_se_golomb(&h->gb);
-         sps->poc_cycle_length                 = get_ue_golomb(&h->gb);
+         sps->delta_pic_order_always_zero_flag = get_bits1(gb);
+         sps->offset_for_non_ref_pic           = get_se_golomb(gb);
+         sps->offset_for_top_to_bottom_field   = get_se_golomb(gb);
+         sps->poc_cycle_length                 = get_ue_golomb(gb);
  
          if ((unsigned)sps->poc_cycle_length >=
              FF_ARRAY_ELEMS(sps->offset_for_ref_frame)) {
-             av_log(h->avctx, AV_LOG_ERROR,
+             av_log(avctx, AV_LOG_ERROR,
                     "poc_cycle_length overflow %d\n", sps->poc_cycle_length);
              goto fail;
          }
  
          for (i = 0; i < sps->poc_cycle_length; i++)
-             sps->offset_for_ref_frame[i] = get_se_golomb(&h->gb);
+             sps->offset_for_ref_frame[i] = get_se_golomb(gb);
      } else if (sps->poc_type != 2) {
-         av_log(h->avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
+         av_log(avctx, AV_LOG_ERROR, "illegal POC type %d\n", sps->poc_type);
          goto fail;
      }
  
-     sps->ref_frame_count = get_ue_golomb_31(&h->gb);
-     if (h->avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
+     sps->ref_frame_count = get_ue_golomb_31(gb);
++    if (avctx->codec_tag == MKTAG('S', 'M', 'V', '2'))
 +        sps->ref_frame_count = FFMAX(2, sps->ref_frame_count);
      if (sps->ref_frame_count > H264_MAX_PICTURE_COUNT - 2 ||
 -        sps->ref_frame_count >= 32U) {
 +        sps->ref_frame_count > 16U) {
-         av_log(h->avctx, AV_LOG_ERROR,
+         av_log(avctx, AV_LOG_ERROR,
                 "too many reference frames %d\n", sps->ref_frame_count);
          goto fail;
      }
-     sps->gaps_in_frame_num_allowed_flag = get_bits1(&h->gb);
-     sps->mb_width                       = get_ue_golomb(&h->gb) + 1;
-     sps->mb_height                      = get_ue_golomb(&h->gb) + 1;
+     sps->gaps_in_frame_num_allowed_flag = get_bits1(gb);
+     sps->mb_width                       = get_ue_golomb(gb) + 1;
+     sps->mb_height                      = get_ue_golomb(gb) + 1;
      if ((unsigned)sps->mb_width  >= INT_MAX / 16 ||
          (unsigned)sps->mb_height >= INT_MAX / 16 ||
          av_image_check_size(16 * sps->mb_width,
-                             16 * sps->mb_height, 0, h->avctx)) {
-         av_log(h->avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
+                             16 * sps->mb_height, 0, avctx)) {
+         av_log(avctx, AV_LOG_ERROR, "mb_width/height overflow\n");
          goto fail;
      }
  
-     sps->frame_mbs_only_flag = get_bits1(&h->gb);
+     sps->frame_mbs_only_flag = get_bits1(gb);
      if (!sps->frame_mbs_only_flag)
-         sps->mb_aff = get_bits1(&h->gb);
+         sps->mb_aff = get_bits1(gb);
      else
          sps->mb_aff = 0;
  
-     sps->direct_8x8_inference_flag = get_bits1(&h->gb);
+     sps->direct_8x8_inference_flag = get_bits1(gb);
 -    if (!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "This stream was generated by a broken encoder, invalid 8x8 inference\n");
 -        goto fail;
 -    }
  
  #ifndef ALLOW_INTERLACE
      if (sps->mb_aff)
-         av_log(h->avctx, AV_LOG_ERROR,
+         av_log(avctx, AV_LOG_ERROR,
                 "MBAFF support not included; enable it at compile-time.\n");
  #endif
-     sps->crop = get_bits1(&h->gb);
+     sps->crop = get_bits1(gb);
      if (sps->crop) {
-         unsigned int crop_left   = get_ue_golomb(&h->gb);
-         unsigned int crop_right  = get_ue_golomb(&h->gb);
-         unsigned int crop_top    = get_ue_golomb(&h->gb);
-         unsigned int crop_bottom = get_ue_golomb(&h->gb);
+         unsigned int crop_left   = get_ue_golomb(gb);
+         unsigned int crop_right  = get_ue_golomb(gb);
+         unsigned int crop_top    = get_ue_golomb(gb);
+         unsigned int crop_bottom = get_ue_golomb(gb);
 +        int width  = 16 * sps->mb_width;
 +        int height = 16 * sps->mb_height * (2 - sps->frame_mbs_only_flag);
  
-         if (h->avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
-             av_log(h->avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
+         if (avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP) {
+             av_log(avctx, AV_LOG_DEBUG, "discarding sps cropping, original "
                                             "values are l:%d r:%d t:%d b:%d\n",
                     crop_left, crop_right, crop_top, crop_bottom);
  
              int step_y = (2 - sps->frame_mbs_only_flag) << vsub;
  
              if (crop_left & (0x1F >> (sps->bit_depth_luma > 8)) &&
-                 !(h->avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
+                 !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
                  crop_left &= ~(0x1F >> (sps->bit_depth_luma > 8));
-                 av_log(h->avctx, AV_LOG_WARNING,
+                 av_log(avctx, AV_LOG_WARNING,
                         "Reducing left cropping to %d "
                         "chroma samples to preserve alignment.\n",
                         crop_left);
              }
  
 -            if (INT_MAX / step_x             <= crop_left               ||
 -                INT_MAX / step_x - crop_left <= crop_right              ||
 -                16 * sps->mb_width <= step_x * (crop_left + crop_right) ||
 -                INT_MAX / step_y             <= crop_top                ||
 -                INT_MAX / step_y - crop_top  <= crop_bottom             ||
 -                16 * sps->mb_height <= step_y * (crop_top + crop_bottom)) {
 -                av_log(avctx, AV_LOG_WARNING, "Invalid crop parameters\n");
 -                if (avctx->err_recognition & AV_EF_EXPLODE)
 -                    goto fail;
 -                crop_left = crop_right = crop_top = crop_bottom = 0;
 +            if (crop_left  > (unsigned)INT_MAX / 4 / step_x ||
 +                crop_right > (unsigned)INT_MAX / 4 / step_x ||
 +                crop_top   > (unsigned)INT_MAX / 4 / step_y ||
 +                crop_bottom> (unsigned)INT_MAX / 4 / step_y ||
 +                (crop_left + crop_right ) * step_x >= width ||
 +                (crop_top  + crop_bottom) * step_y >= height
 +            ) {
-                 av_log(h->avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
++                av_log(avctx, AV_LOG_ERROR, "crop values invalid %d %d %d %d / %d %d\n", crop_left, crop_right, crop_top, crop_bottom, width, height);
 +                goto fail;
              }
  
              sps->crop_left   = crop_left   * step_x;
          sps->crop        = 0;
      }
  
-     sps->vui_parameters_present_flag = get_bits1(&h->gb);
+     sps->vui_parameters_present_flag = get_bits1(gb);
      if (sps->vui_parameters_present_flag) {
-         int ret = decode_vui_parameters(h, sps);
+         int ret = decode_vui_parameters(gb, avctx, sps);
 -        if (ret < 0 && avctx->err_recognition & AV_EF_EXPLODE)
 +        if (ret < 0)
 +            goto fail;
 +    }
 +
-     if (get_bits_left(&h->gb) < 0) {
-         av_log(h->avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
-                "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(&h->gb));
++    if (get_bits_left(gb) < 0) {
++        av_log(avctx, ignore_truncation ? AV_LOG_WARNING : AV_LOG_ERROR,
++               "Overread %s by %d bits\n", sps->vui_parameters_present_flag ? "VUI" : "SPS", -get_bits_left(gb));
 +        if (!ignore_truncation)
              goto fail;
      }
  
      if (!sps->sar.den)
          sps->sar.den = 1;
  
-     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
+     if (avctx->debug & FF_DEBUG_PICT_INFO) {
          static const char csp[4][5] = { "Gray", "420", "422", "444" };
-         av_log(h->avctx, AV_LOG_DEBUG,
+         av_log(avctx, AV_LOG_DEBUG,
 -               "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32"\n",
 +               "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%u/%u/%u/%u %s %s %"PRId32"/%"PRId32" b%d reo:%d\n",
                 sps_id, sps->profile_idc, sps->level_idc,
                 sps->poc_type,
                 sps->ref_frame_count,
                 sps->vui_parameters_present_flag ? "VUI" : "",
                 csp[sps->chroma_format_idc],
                 sps->timing_info_present_flag ? sps->num_units_in_tick : 0,
 -               sps->timing_info_present_flag ? sps->time_scale : 0);
 +               sps->timing_info_present_flag ? sps->time_scale : 0,
 +               sps->bit_depth_luma,
 +               sps->bitstream_restriction_flag ? sps->num_reorder_frames : -1
 +               );
      }
-     sps->new = 1;
  
-     av_free(h->sps_buffers[sps_id]);
-     h->sps_buffers[sps_id] = sps;
+     /* check if this is a repeat of an already parsed SPS, then keep the
+      * original one.
+      * otherwise drop all PPSes that depend on it */
+     if (ps->sps_list[sps_id] &&
+         !memcmp(ps->sps_list[sps_id]->data, sps_buf->data, sps_buf->size)) {
+         av_buffer_unref(&sps_buf);
+     } else {
+         remove_sps(ps, sps_id);
+         ps->sps_list[sps_id] = sps_buf;
+     }
  
      return 0;
  
  fail:
-     av_free(sps);
+     av_buffer_unref(&sps_buf);
      return AVERROR_INVALIDDATA;
  }
  
+ static void init_dequant8_coeff_table(PPS *pps, const SPS *sps)
+ {
+     int i, j, q, x;
+     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
+     for (i = 0; i < 6; i++) {
+         pps->dequant8_coeff[i] = pps->dequant8_buffer[i];
+         for (j = 0; j < i; j++)
+             if (!memcmp(pps->scaling_matrix8[j], pps->scaling_matrix8[i],
+                         64 * sizeof(uint8_t))) {
+                 pps->dequant8_coeff[i] = pps->dequant8_buffer[j];
+                 break;
+             }
+         if (j < i)
+             continue;
+         for (q = 0; q < max_qp + 1; q++) {
+             int shift = ff_h264_quant_div6[q];
+             int idx   = ff_h264_quant_rem6[q];
+             for (x = 0; x < 64; x++)
+                 pps->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
+                     ((uint32_t)ff_h264_dequant8_coeff_init[idx][ff_h264_dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
+                      pps->scaling_matrix8[i][x]) << shift;
+         }
+     }
+ }
+ static void init_dequant4_coeff_table(PPS *pps, const SPS *sps)
+ {
+     int i, j, q, x;
+     const int max_qp = 51 + 6 * (sps->bit_depth_luma - 8);
+     for (i = 0; i < 6; i++) {
+         pps->dequant4_coeff[i] = pps->dequant4_buffer[i];
+         for (j = 0; j < i; j++)
+             if (!memcmp(pps->scaling_matrix4[j], pps->scaling_matrix4[i],
+                         16 * sizeof(uint8_t))) {
+                 pps->dequant4_coeff[i] = pps->dequant4_buffer[j];
+                 break;
+             }
+         if (j < i)
+             continue;
+         for (q = 0; q < max_qp + 1; q++) {
+             int shift = ff_h264_quant_div6[q] + 2;
+             int idx   = ff_h264_quant_rem6[q];
+             for (x = 0; x < 16; x++)
+                 pps->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
+                     ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
+                      pps->scaling_matrix4[i][x]) << shift;
+         }
+     }
+ }
+ static void init_dequant_tables(PPS *pps, const SPS *sps)
+ {
+     int i, x;
+     init_dequant4_coeff_table(pps, sps);
++    memset(pps->dequant8_coeff, 0, sizeof(pps->dequant8_coeff));
++
+     if (pps->transform_8x8_mode)
+         init_dequant8_coeff_table(pps, sps);
+     if (sps->transform_bypass) {
+         for (i = 0; i < 6; i++)
+             for (x = 0; x < 16; x++)
+                 pps->dequant4_coeff[i][0][x] = 1 << 6;
+         if (pps->transform_8x8_mode)
+             for (i = 0; i < 6; i++)
+                 for (x = 0; x < 64; x++)
+                     pps->dequant8_coeff[i][0][x] = 1 << 6;
+     }
+ }
  static void build_qp_table(PPS *pps, int t, int index, const int depth)
  {
      int i;
              ff_h264_chroma_qp[depth - 8][av_clip(i + index, 0, max_qp)];
  }
  
- static int more_rbsp_data_in_pps(H264Context *h, PPS *pps)
++static int more_rbsp_data_in_pps(const SPS *sps, void *logctx)
 +{
-     const SPS *sps = h->sps_buffers[pps->sps_id];
 +    int profile_idc = sps->profile_idc;
 +
 +    if ((profile_idc == 66 || profile_idc == 77 ||
 +         profile_idc == 88) && (sps->constraint_set_flags & 7)) {
-         av_log(h->avctx, AV_LOG_VERBOSE,
++        av_log(logctx, AV_LOG_VERBOSE,
 +               "Current profile doesn't provide more RBSP data in PPS, skipping\n");
 +        return 0;
 +    }
 +
 +    return 1;
 +}
 +
- int ff_h264_decode_picture_parameter_set(H264Context *h, int bit_length)
+ int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+                                          H264ParamSets *ps, int bit_length)
  {
-     const SPS *sps;
-     unsigned int pps_id = get_ue_golomb(&h->gb);
+     AVBufferRef *pps_buf;
+     SPS *sps;
+     unsigned int pps_id = get_ue_golomb(gb);
      PPS *pps;
      int qp_bd_offset;
      int bits_left;
      int ret;
  
      if (pps_id >= MAX_PPS_COUNT) {
-         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
+         av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
          return AVERROR_INVALIDDATA;
      }
  
-     pps = av_mallocz(sizeof(PPS));
-     if (!pps)
+     pps_buf = av_buffer_allocz(sizeof(*pps));
+     if (!pps_buf)
          return AVERROR(ENOMEM);
-     pps->data_size = h->gb.buffer_end - h->gb.buffer;
+     pps = (PPS*)pps_buf->data;
++    pps->data_size = gb->buffer_end - gb->buffer;
 +    if (pps->data_size > sizeof(pps->data)) {
-         av_log(h->avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
++        av_log(avctx, AV_LOG_WARNING, "Truncating likely oversized PPS\n");
 +        pps->data_size = sizeof(pps->data);
 +    }
-     memcpy(pps->data, h->gb.buffer, pps->data_size);
-     pps->sps_id = get_ue_golomb_31(&h->gb);
++    memcpy(pps->data, gb->buffer, pps->data_size);
++
+     pps->sps_id = get_ue_golomb_31(gb);
      if ((unsigned)pps->sps_id >= MAX_SPS_COUNT ||
-         !h->sps_buffers[pps->sps_id]) {
-         av_log(h->avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
+         !ps->sps_list[pps->sps_id]) {
+         av_log(avctx, AV_LOG_ERROR, "sps_id %u out of range\n", pps->sps_id);
          ret = AVERROR_INVALIDDATA;
          goto fail;
      }
-     sps = h->sps_buffers[pps->sps_id];
+     sps = (SPS*)ps->sps_list[pps->sps_id]->data;
 -
 -    if (sps->bit_depth_luma > 10) {
 +    if (sps->bit_depth_luma > 14) {
-         av_log(h->avctx, AV_LOG_ERROR,
++        av_log(avctx, AV_LOG_ERROR,
 +               "Invalid luma bit depth=%d\n",
 +               sps->bit_depth_luma);
 +        ret = AVERROR_INVALIDDATA;
 +        goto fail;
 +    } else if (sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13) {
-         av_log(h->avctx, AV_LOG_ERROR,
+         av_log(avctx, AV_LOG_ERROR,
 -               "Unimplemented luma bit depth=%d (max=10)\n",
 +               "Unimplemented luma bit depth=%d\n",
                 sps->bit_depth_luma);
          ret = AVERROR_PATCHWELCOME;
          goto fail;
      }
  
-     pps->cabac             = get_bits1(&h->gb);
-     pps->pic_order_present = get_bits1(&h->gb);
-     pps->slice_group_count = get_ue_golomb(&h->gb) + 1;
+     pps->cabac             = get_bits1(gb);
+     pps->pic_order_present = get_bits1(gb);
+     pps->slice_group_count = get_ue_golomb(gb) + 1;
      if (pps->slice_group_count > 1) {
-         pps->mb_slice_group_map_type = get_ue_golomb(&h->gb);
-         av_log(h->avctx, AV_LOG_ERROR, "FMO not supported\n");
+         pps->mb_slice_group_map_type = get_ue_golomb(gb);
+         av_log(avctx, AV_LOG_ERROR, "FMO not supported\n");
          switch (pps->mb_slice_group_map_type) {
          case 0:
  #if 0
              break;
          }
      }
-     pps->ref_count[0] = get_ue_golomb(&h->gb) + 1;
-     pps->ref_count[1] = get_ue_golomb(&h->gb) + 1;
+     pps->ref_count[0] = get_ue_golomb(gb) + 1;
+     pps->ref_count[1] = get_ue_golomb(gb) + 1;
      if (pps->ref_count[0] - 1 > 32 - 1 || pps->ref_count[1] - 1 > 32 - 1) {
-         av_log(h->avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
+         av_log(avctx, AV_LOG_ERROR, "reference overflow (pps)\n");
          ret = AVERROR_INVALIDDATA;
          goto fail;
      }
  
      qp_bd_offset = 6 * (sps->bit_depth_luma - 8);
  
-     pps->weighted_pred                        = get_bits1(&h->gb);
-     pps->weighted_bipred_idc                  = get_bits(&h->gb, 2);
-     pps->init_qp                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
-     pps->init_qs                              = get_se_golomb(&h->gb) + 26 + qp_bd_offset;
-     pps->chroma_qp_index_offset[0]            = get_se_golomb(&h->gb);
-     pps->deblocking_filter_parameters_present = get_bits1(&h->gb);
-     pps->constrained_intra_pred               = get_bits1(&h->gb);
-     pps->redundant_pic_cnt_present            = get_bits1(&h->gb);
+     pps->weighted_pred                        = get_bits1(gb);
+     pps->weighted_bipred_idc                  = get_bits(gb, 2);
+     pps->init_qp                              = get_se_golomb(gb) + 26 + qp_bd_offset;
+     pps->init_qs                              = get_se_golomb(gb) + 26 + qp_bd_offset;
+     pps->chroma_qp_index_offset[0]            = get_se_golomb(gb);
+     pps->deblocking_filter_parameters_present = get_bits1(gb);
+     pps->constrained_intra_pred               = get_bits1(gb);
+     pps->redundant_pic_cnt_present            = get_bits1(gb);
  
      pps->transform_8x8_mode = 0;
-     // contents of sps/pps can change even if id doesn't, so reinit
-     h->dequant_coeff_pps = -1;
-     memcpy(pps->scaling_matrix4, h->sps_buffers[pps->sps_id]->scaling_matrix4,
+     memcpy(pps->scaling_matrix4, sps->scaling_matrix4,
             sizeof(pps->scaling_matrix4));
-     memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8,
+     memcpy(pps->scaling_matrix8, sps->scaling_matrix8,
             sizeof(pps->scaling_matrix8));
  
-     bits_left = bit_length - get_bits_count(&h->gb);
-     if (bits_left > 0 && more_rbsp_data_in_pps(h, pps)) {
-         pps->transform_8x8_mode = get_bits1(&h->gb);
-         decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0,
+     bits_left = bit_length - get_bits_count(gb);
 -    if (bits_left && (bits_left > 8 ||
 -                      show_bits(gb, bits_left) != 1 << (bits_left - 1))) {
++    if (bits_left > 0 && more_rbsp_data_in_pps(sps, avctx)) {
+         pps->transform_8x8_mode = get_bits1(gb);
+         decode_scaling_matrices(gb, sps, pps, 0,
                                  pps->scaling_matrix4, pps->scaling_matrix8);
          // second_chroma_qp_index_offset
-         pps->chroma_qp_index_offset[1] = get_se_golomb(&h->gb);
+         pps->chroma_qp_index_offset[1] = get_se_golomb(gb);
      } else {
          pps->chroma_qp_index_offset[1] = pps->chroma_qp_index_offset[0];
      }
                     sps->bit_depth_luma);
      build_qp_table(pps, 1, pps->chroma_qp_index_offset[1],
                     sps->bit_depth_luma);
+     init_dequant_tables(pps, sps);
      if (pps->chroma_qp_index_offset[0] != pps->chroma_qp_index_offset[1])
          pps->chroma_qp_diff = 1;
  
-     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
-         av_log(h->avctx, AV_LOG_DEBUG,
+     if (avctx->debug & FF_DEBUG_PICT_INFO) {
+         av_log(avctx, AV_LOG_DEBUG,
                 "pps:%u sps:%u %s slice_groups:%d ref:%u/%u %s qp:%d/%d/%d/%d %s %s %s %s\n",
                 pps_id, pps->sps_id,
                 pps->cabac ? "CABAC" : "CAVLC",
                 pps->transform_8x8_mode ? "8x8DCT" : "");
      }
  
-     av_free(h->pps_buffers[pps_id]);
-     h->pps_buffers[pps_id] = pps;
+     remove_pps(ps, pps_id);
+     ps->pps_list[pps_id] = pps_buf;
      return 0;
  
  fail:
-     av_free(pps);
+     av_buffer_unref(&pps_buf);
      return ret;
  }
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
   */
  
@@@ -27,7 -27,6 +27,7 @@@
  
  #include <inttypes.h>
  
 +#include "libavutil/avassert.h"
  #include "internal.h"
  #include "avcodec.h"
  #include "h264.h"
@@@ -80,18 -79,16 +80,18 @@@ static int build_def_list(H264Ref *def
      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);
          }
@@@ -122,18 -119,9 +122,18 @@@ static int add_sorted(H264Picture **sor
      return out_i;
  }
  
 +static int mismatches_ref(H264Context *h, H264Picture *pic)
 +{
 +    AVFrame *f = pic->f;
 +    return (h->cur_pic_ptr->f->width  != f->width ||
 +            h->cur_pic_ptr->f->height != f->height ||
 +            h->cur_pic_ptr->f->format != f->format);
 +}
 +
  static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
  {
      int i, len;
 +    int j;
  
      if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
          H264Picture *sorted[32];
          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(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),
                                    sorted, len, 0, h->picture_structure);
              len += build_def_list(sl->ref_list[list] + len,
                                    FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
                                    h->long_ref, 16, 1, h->picture_structure);
 +            av_assert0(len <= 32);
  
              if (len < sl->ref_count[list])
                  memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));
          len += build_def_list(sl->ref_list[0] + len,
                                FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
                                h-> long_ref, 16, 1, h->picture_structure);
 +        av_assert0(len <= 32);
  
          if (len < sl->ref_count[0])
              memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len));
      }
 +#ifdef TRACE
 +    for (i = 0; i < sl->ref_count[0]; i++) {
 +        ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",
 +                (sl->ref_list[0][i].parent ? (sl->ref_list[0][i].parent->long_ref ? "LT" : "ST") : "??"),
 +                sl->ref_list[0][i].pic_id,
 +                sl->ref_list[0][i].data[0]);
 +    }
 +    if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 +        for (i = 0; i < sl->ref_count[1]; i++) {
 +            ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",
 +                    (sl->ref_list[1][i].parent ? (sl->ref_list[1][i].parent->long_ref ? "LT" : "ST") : "??"),
 +                    sl->ref_list[1][i].pic_id,
 +                    sl->ref_list[1][i].data[0]);
 +        }
 +    }
 +#endif
 +
 +    for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {
 +        for (i = 0; i < sl->ref_count[j]; i++) {
 +            if (sl->ref_list[j][i].parent) {
 +                if (mismatches_ref(h, sl->ref_list[j][i].parent)) {
 +                    av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");
 +                    memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));
 +                }
 +            }
 +        }
 +    }
 +    for (i = 0; i < sl->list_count; i++)
 +        h->default_ref[i] = sl->ref_list[i][0];
  }
  
  static void print_short_term(H264Context *h);
@@@ -268,7 -225,7 +268,7 @@@ int ff_h264_decode_ref_pic_list_reorder
                  switch (modification_of_pic_nums_idc) {
                  case 0:
                  case 1: {
 -                    const unsigned int abs_diff_pic_num = get_ue_golomb(&sl->gb) + 1;
 +                    const unsigned int abs_diff_pic_num = get_ue_golomb_long(&sl->gb) + 1;
                      int frame_num;
  
                      if (abs_diff_pic_num > h->max_pic_num) {
  
                      long_idx = pic_num_extract(h, pic_id, &pic_structure);
  
 -                    if (long_idx > 31) {
 +                    if (long_idx > 31U) {
                          av_log(h->avctx, AV_LOG_ERROR,
                                 "long_term_pic_idx overflow\n");
                          return AVERROR_INVALIDDATA;
                      }
                      ref = h->long_ref[long_idx];
                      assert(!(ref && !ref->reference));
 -                    if (ref && (ref->reference & pic_structure)) {
 +                    if (ref && (ref->reference & pic_structure) && !mismatches_ref(h, ref)) {
                          ref->pic_id = pic_id;
                          assert(ref->long_ref);
                          i = 0;
      }
      for (list = 0; list < sl->list_count; list++) {
          for (index = 0; index < sl->ref_count[list]; index++) {
 -            if (!sl->ref_list[list][index].parent) {
 -                av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture\n");
 -                if (index == 0 || h->avctx->err_recognition & AV_EF_EXPLODE)
 -                    return AVERROR_INVALIDDATA;
 +            if (   !sl->ref_list[list][index].parent
 +                || (!FIELD_PICTURE(h) && (sl->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].poc);
 +                for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
 +                    h->last_pocs[i] = INT_MIN;
 +                if (h->default_ref[list].parent
 +                    && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
 +                    sl->ref_list[list][index] = h->default_ref[list];
                  else
 -                    sl->ref_list[list][index] = sl->ref_list[list][index - 1];
 +                    return -1;
              }
 +            av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
          }
      }
  
  void ff_h264_fill_mbaff_ref_list(H264Context *h, H264SliceContext *sl)
  {
      int list, i, j;
 -    for (list = 0; list < sl->list_count; list++) { //FIXME try list_count
 +    for (list = 0; list < sl->list_count; list++) {
          for (i = 0; i < sl->ref_count[list]; i++) {
              H264Ref *frame = &sl->ref_list[list][i];
              H264Ref *field = &sl->ref_list[list][16 + 2 * i];
@@@ -517,24 -468,11 +517,24 @@@ void ff_h264_remove_all_refs(H264Contex
      }
      assert(h->long_ref_count == 0);
  
 +    if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
 +        ff_h264_unref_picture(h, &h->last_pic_for_ec);
 +        if (h->short_ref[0]->f->buf[0])
 +            ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
 +    }
 +
      for (i = 0; i < h->short_ref_count; i++) {
          unreference_pic(h, h->short_ref[i], 0);
          h->short_ref[i] = NULL;
      }
      h->short_ref_count = 0;
 +
 +    memset(h->default_ref, 0, sizeof(h->default_ref));
 +    for (i = 0; i < h->nb_slice_ctx; i++) {
 +        H264SliceContext *sl = &h->slice_ctx[i];
 +        sl->list_count = sl->ref_count[0] = sl->ref_count[1] = 0;
 +        memset(sl->ref_list, 0, sizeof(sl->ref_list));
 +    }
  }
  
  /**
@@@ -576,11 -514,8 +576,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;
@@@ -591,8 -526,10 +591,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->ps.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->ps.sps->ref_frame_count &&
++        h->long_ref_count + h->short_ref_count >= h->ps.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_ref_count[2] = {0};
      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);
 +            }
  
              /* make sure the current picture is not already assigned as a long ref */
              if (h->cur_pic_ptr->long_ref) {
                  for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
 -                    if (h->long_ref[j] == h->cur_pic_ptr)
 +                    if (h->long_ref[j] == h->cur_pic_ptr) {
 +                        if (j != mmco[i].long_arg)
 +                            av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
                          remove_long(h, j, 0);
 +                    }
                  }
              }
  
 -
              if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
 +                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->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
              /* Just mark the second field valid */
 -            h->cur_pic_ptr->reference = PICT_FRAME;
 +            h->cur_pic_ptr->reference |= h->picture_structure;
          } else if (h->cur_pic_ptr->long_ref) {
              av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
                                             "assignment for second field "
          }
      }
  
-     if (h->long_ref_count + h->short_ref_count > FFMAX(h->sps.ref_frame_count, 1)) {
 -    if (h->long_ref_count + h->short_ref_count -
 -        (h->short_ref[0] == h->cur_pic_ptr) > h->ps.sps->ref_frame_count) {
++    if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.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
          av_log(h->avctx, AV_LOG_ERROR,
                 "number of reference frames (%d+%d) exceeds max (%d; probably "
                 "corrupt input), discarding one\n",
-                h->long_ref_count, h->short_ref_count, h->sps.ref_frame_count);
+                h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
          err = AVERROR_INVALIDDATA;
  
          if (h->long_ref_count && !h->short_ref_count) {
          }
      }
  
-             int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->sps.log2_max_frame_num);
-             if (d > h->sps.ref_frame_count)
 +    for (i = 0; i<h->short_ref_count; i++) {
 +        pic = h->short_ref[i];
 +        if (pic->invalid_gap) {
++            int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
++            if (d > h->ps.sps->ref_frame_count)
 +                remove_short(h, pic->frame_num, 0);
 +        }
 +    }
 +
      print_short_term(h);
      print_long_term(h);
-     for (i = 0; i < FF_ARRAY_ELEMS(h->pps_buffers); i++) {
-         if (h->pps_buffers[i]) {
-             pps_ref_count[0] = FFMAX(pps_ref_count[0], h->pps_buffers[i]->ref_count[0]);
-             pps_ref_count[1] = FFMAX(pps_ref_count[1], h->pps_buffers[i]->ref_count[1]);
 +
++    for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
++        if (h->ps.pps_list[i]) {
++            const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
++            pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
++            pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
 +        }
 +    }
 +
 +    if (   err >= 0
 +        && h->long_ref_count==0
 +        && (   h->short_ref_count<=2
 +            || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
 +        && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
 +        && 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;
  }
  
@@@ -830,7 -732,7 +831,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
                  mmco[i].opcode = opcode;
                  if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
                      mmco[i].short_pic_num =
 -                        (h->curr_pic_num - get_ue_golomb(gb) - 1) &
 +                        (h->curr_pic_num - get_ue_golomb_long(gb) - 1) &
                              (h->max_pic_num - 1);
  #if 0
                      if (mmco[i].short_pic_num >= h->short_ref_count ||
      }
  
      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/h264_sei.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... sei 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
   */
  
@@@ -50,18 -50,17 +50,23 @@@ void ff_h264_reset_sei(H264Context *h
  
  static int decode_picture_timing(H264Context *h)
  {
-     SPS *sps = &h->sps;
+     const SPS *sps = h->ps.sps;
 +    int i;
  
 -    if (!sps)
 -        return AVERROR_INVALIDDATA;
 +    for (i = 0; i<MAX_SPS_COUNT; i++)
-         if (!sps->log2_max_frame_num && h->sps_buffers[i])
-             sps = h->sps_buffers[i];
++        if ((!sps || !sps->log2_max_frame_num) && h->ps.sps_list[i])
++            sps = (const SPS *)h->ps.sps_list[i]->data;
++
++    if (!sps) {
++        av_log(h->avctx, AV_LOG_ERROR, "SPS unavailable in decode_picture_timing\n");
++        return 0;
++    }
  
 -    if (sps->nal_hrd_parameters_present_flag ||
 -        sps->vcl_hrd_parameters_present_flag) {
 -        h->sei_cpb_removal_delay = get_bits(&h->gb,
 -                                            sps->cpb_removal_delay_length);
 -        h->sei_dpb_output_delay  = get_bits(&h->gb,
 -                                            sps->dpb_output_delay_length);
 +    if (sps->nal_hrd_parameters_present_flag || sps->vcl_hrd_parameters_present_flag) {
 +        h->sei_cpb_removal_delay = get_bits_long(&h->gb,
 +                                                 sps->cpb_removal_delay_length);
 +        h->sei_dpb_output_delay  = get_bits_long(&h->gb,
 +                                                 sps->dpb_output_delay_length);
      }
      if (sps->pic_struct_present_flag) {
          unsigned int i, num_clock_ts;
@@@ -128,11 -127,6 +133,11 @@@ static int decode_registered_user_data_
          skip_bits(&h->gb, 4);           // reserved
          h->active_format_description   = get_bits(&h->gb, 4);
          h->sei_reguserdata_afd_present = 1;
 +#if FF_API_AFD
 +FF_DISABLE_DEPRECATION_WARNINGS
 +        h->avctx->dtg_active_format = h->active_format_description;
 +FF_ENABLE_DEPRECATION_WARNINGS
 +#endif /* FF_API_AFD */
      }
  
      return 0;
@@@ -182,6 -176,8 +187,6 @@@ static int decode_registered_user_data_
          }
      } else {
          int i;
 -        avpriv_request_sample(h->avctx, "Subtitles with data type 0x%02x",
 -                              user_data_type_code);
          for (i = 0; i < size - 1; i++)
              skip_bits(&h->gb, 8);
      }
@@@ -241,8 -237,6 +246,8 @@@ static int decode_unregistered_user_dat
      e = sscanf(user_data + 16, "x264 - core %d", &build);
      if (e == 1 && build > 0)
          h->x264_build = build;
 +    if (e == 1 && build == 1 && !strncmp(user_data+16, "x264 - core 0000", 16))
 +        h->x264_build = 67;
  
      if (strlen(user_data + 16) > 0)
          av_log(h->avctx, AV_LOG_DEBUG, "user data:\"%s\"\n", user_data + 16);
  
  static int decode_recovery_point(H264Context *h)
  {
 -    h->sei_recovery_frame_cnt = get_ue_golomb(&h->gb);
 +    h->sei_recovery_frame_cnt = get_ue_golomb_long(&h->gb);
  
      /* 1b exact_match_flag,
       * 1b broken_link_flag,
       * 2b changing_slice_group_idc */
      skip_bits(&h->gb, 4);
  
 +    if (h->avctx->debug & FF_DEBUG_PICT_INFO)
 +        av_log(h->avctx, AV_LOG_DEBUG, "sei_recovery_frame_cnt: %d\n", h->sei_recovery_frame_cnt);
 +
 +    h->has_recovery_point = 1;
 +
      return 0;
  }
  
@@@ -275,18 -264,18 +280,18 @@@ static int decode_buffering_period(H264
      SPS *sps;
  
      sps_id = get_ue_golomb_31(&h->gb);
-     if (sps_id > 31 || !h->sps_buffers[sps_id]) {
+     if (sps_id > 31 || !h->ps.sps_list[sps_id]) {
          av_log(h->avctx, AV_LOG_ERROR,
                 "non-existing SPS %d referenced in buffering period\n", sps_id);
          return AVERROR_INVALIDDATA;
      }
-     sps = h->sps_buffers[sps_id];
+     sps = (SPS*)h->ps.sps_list[sps_id]->data;
  
      // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
      if (sps->nal_hrd_parameters_present_flag) {
          for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
              h->initial_cpb_removal_delay[sched_sel_idx] =
 -                get_bits(&h->gb, sps->initial_cpb_removal_delay_length);
 +                get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length);
              // initial_cpb_removal_delay_offset
              skip_bits(&h->gb, sps->initial_cpb_removal_delay_length);
          }
      if (sps->vcl_hrd_parameters_present_flag) {
          for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
              h->initial_cpb_removal_delay[sched_sel_idx] =
 -                get_bits(&h->gb, sps->initial_cpb_removal_delay_length);
 +                get_bits_long(&h->gb, sps->initial_cpb_removal_delay_length);
              // initial_cpb_removal_delay_offset
              skip_bits(&h->gb, sps->initial_cpb_removal_delay_length);
          }
  
  static int decode_frame_packing_arrangement(H264Context *h)
  {
 -    get_ue_golomb(&h->gb);              // frame_packing_arrangement_id
 -    h->sei_frame_packing_present = !get_bits1(&h->gb);
 +    h->sei_fpa.frame_packing_arrangement_id          = get_ue_golomb_long(&h->gb);
 +    h->sei_fpa.frame_packing_arrangement_cancel_flag = get_bits1(&h->gb);
 +    h->sei_frame_packing_present = !h->sei_fpa.frame_packing_arrangement_cancel_flag;
  
      if (h->sei_frame_packing_present) {
 +        h->sei_fpa.frame_packing_arrangement_type =
          h->frame_packing_arrangement_type = get_bits(&h->gb, 7);
 +        h->sei_fpa.quincunx_sampling_flag         =
          h->quincunx_subsampling           = get_bits1(&h->gb);
 +        h->sei_fpa.content_interpretation_type    =
          h->content_interpretation_type    = get_bits(&h->gb, 6);
  
          // the following skips: spatial_flipping_flag, frame0_flipped_flag,
          if (!h->quincunx_subsampling && h->frame_packing_arrangement_type != 5)
              skip_bits(&h->gb, 16);      // frame[01]_grid_position_[xy]
          skip_bits(&h->gb, 8);           // frame_packing_arrangement_reserved_byte
 -        get_ue_golomb(&h->gb);          // frame_packing_arrangement_repetition_period
 +        h->sei_fpa.frame_packing_arrangement_repetition_period = get_ue_golomb_long(&h->gb);
      }
      skip_bits1(&h->gb);                 // frame_packing_arrangement_extension_flag
  
 +    if (h->avctx->debug & FF_DEBUG_PICT_INFO)
 +        av_log(h->avctx, AV_LOG_DEBUG, "SEI FPA %d %d %d %d %d %d\n",
 +                                       h->sei_fpa.frame_packing_arrangement_id,
 +                                       h->sei_fpa.frame_packing_arrangement_cancel_flag,
 +                                       h->sei_fpa.frame_packing_arrangement_type,
 +                                       h->sei_fpa.quincunx_sampling_flag,
 +                                       h->sei_fpa.content_interpretation_type,
 +                                       h->sei_fpa.frame_packing_arrangement_repetition_period);
 +
      return 0;
  }
  
@@@ -351,68 -327,8 +356,68 @@@ static int decode_display_orientation(H
          h->sei_vflip = get_bits1(&h->gb);     // ver_flip
  
          h->sei_anticlockwise_rotation = get_bits(&h->gb, 16);
 -        get_ue_golomb(&h->gb);  // display_orientation_repetition_period
 -        skip_bits1(&h->gb);     // display_orientation_extension_flag
 +        get_ue_golomb_long(&h->gb);  // display_orientation_repetition_period
 +        skip_bits1(&h->gb);          // display_orientation_extension_flag
 +    }
 +
 +    return 0;
 +}
 +
 +static int decode_GreenMetadata(H264Context *h)
 +{
 +    if (h->avctx->debug & FF_DEBUG_GREEN_MD)
 +        av_log(h->avctx, AV_LOG_DEBUG,          "Green Metadata Info SEI message\n");
 +
 +    h->sei_green_metadata.green_metadata_type=get_bits(&h->gb, 8);
 +
 +    if (h->avctx->debug & FF_DEBUG_GREEN_MD)
 +        av_log(h->avctx, AV_LOG_DEBUG,          "green_metadata_type                            = %d\n",
 +               h->sei_green_metadata.green_metadata_type);
 +
 +    if (h->sei_green_metadata.green_metadata_type==0){
 +        h->sei_green_metadata.period_type=get_bits(&h->gb, 8);
 +
 +        if (h->avctx->debug & FF_DEBUG_GREEN_MD)
 +            av_log(h->avctx, AV_LOG_DEBUG,      "green_metadata_period_type                     = %d\n",
 +                   h->sei_green_metadata.period_type);
 +
 +        if (h->sei_green_metadata.green_metadata_type==2){
 +            h->sei_green_metadata.num_seconds = get_bits(&h->gb, 16);
 +            if (h->avctx->debug & FF_DEBUG_GREEN_MD)
 +                av_log(h->avctx, AV_LOG_DEBUG,  "green_metadata_num_seconds                     = %d\n",
 +                       h->sei_green_metadata.num_seconds);
 +        }
 +        else if (h->sei_green_metadata.period_type==3){
 +            h->sei_green_metadata.num_pictures = get_bits(&h->gb, 16);
 +            if (h->avctx->debug & FF_DEBUG_GREEN_MD)
 +                av_log(h->avctx, AV_LOG_DEBUG,  "green_metadata_num_pictures                    = %d\n",
 +                       h->sei_green_metadata.num_pictures);