Merge commit '6490a0c0fbe0e55f765ea2aa2e8495181ea1f719'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 21 Mar 2015 16:23:10 +0000 (17:23 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 21 Mar 2015 16:23:10 +0000 (17:23 +0100)
* commit '6490a0c0fbe0e55f765ea2aa2e8495181ea1f719':
  h264_mb: constify all uses of H264Context

Conflicts:
libavcodec/h264.h
libavcodec/h264_mb.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/h264.h
libavcodec/h264_mb.c
libavcodec/h264_mb_template.c
libavcodec/h264_mc_template.c

diff --combined libavcodec/h264.h
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "h264dsp.h"
  #include "h264pred.h"
  #include "h264qpel.h"
 +#include "internal.h" // for avpriv_find_start_code()
  #include "mpegutils.h"
  #include "parser.h"
  #include "qpeldsp.h"
  #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
@@@ -53,8 -52,6 +53,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(h)    (h)->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 FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
  
  #ifndef CABAC
 -#define CABAC(h) h->pps.cabac
 +#define CABAC(h) (h)->pps.cabac
  #endif
  
 -#define CHROMA422(h) (h->sps.chroma_format_idc == 2)
 -#define CHROMA444(h) (h->sps.chroma_format_idc == 3)
 +#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 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 {
  typedef enum {
      SEI_TYPE_BUFFERING_PERIOD       = 0,   ///< buffering period (H.264, D.1.1)
      SEI_TYPE_PIC_TIMING             = 1,   ///< picture timing
 +    SEI_TYPE_USER_DATA_ITU_T_T35    = 4,   ///< user data registered by ITU-T Recommendation T.35
      SEI_TYPE_USER_DATA_UNREGISTERED = 5,   ///< unregistered user data
      SEI_TYPE_RECOVERY_POINT         = 6,   ///< recovery point (frame # to decoder sync)
      SEI_TYPE_FRAME_PACKING          = 45,  ///< frame packing arrangement
@@@ -154,19 -149,6 +154,19 @@@ typedef enum 
      SEI_PIC_STRUCT_FRAME_TRIPLING    = 8  ///<  8: %frame tripling
  } 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
   */
@@@ -251,22 -233,10 +251,22 @@@ typedef struct PPS 
      int transform_8x8_mode;         ///< transform_8x8_mode_flag
      uint8_t scaling_matrix4[6][16];
      uint8_t scaling_matrix8[6][64];
 -    uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
 +    uint8_t chroma_qp_table[2][QP_MAX_NUM+1];  ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
      int chroma_qp_diff;
  } PPS;
  
 +/**
 + * Frame Packing Arrangement Type
 + */
 +typedef struct FPA {
 +    int         frame_packing_arrangement_id;
 +    int         frame_packing_arrangement_cancel_flag; ///< is previous arrangement canceled, -1 if never received
 +    SEI_FpaType frame_packing_arrangement_type;
 +    int         frame_packing_arrangement_repetition_period;
 +    int         content_interpretation_type;
 +    int         quincunx_sampling_flag;
 +} FPA;
 +
  /**
   * Memory management control operation opcode.
   */
@@@ -291,7 -261,6 +291,7 @@@ typedef struct MMCO 
  
  typedef struct H264Picture {
      struct AVFrame f;
 +    uint8_t avframe_padding[1024]; // hack to allow linking to a avutil with larger AVFrame
      ThreadFrame tf;
  
      AVBufferRef *qscale_table_buf;
      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 needs_realloc;      ///< picture needs to be reallocated (eg due to a frame size change)
      int reference;
      int recovered;          ///< picture at IDR or recovery point + recovery count
 +    int invalid_gap;
 +    int sei_recovery_frame_cnt;
 +
 +    int crop;
 +    int crop_left;
 +    int crop_top;
  } H264Picture;
  
  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
   * H264Context
   */
  typedef struct H264Context {
 +    AVClass *av_class;
      AVCodecContext *avctx;
      VideoDSPContext vdsp;
      H264DSPContext h264dsp;
      H264Picture *DPB;
      H264Picture *cur_pic_ptr;
      H264Picture cur_pic;
 +    H264Picture last_pic_for_ec;
  
      H264SliceContext *slice_ctx;
      int            nb_slice_ctx;
      uint32_t *mb2br_xy;
      int b_stride;       // FIXME use s->b4_stride
  
 +
 +    unsigned current_sps_id; ///< id of the current SPS
      SPS sps; ///< current sps
      PPS pps; ///< current pps
  
 +    int au_pps_id; ///< pps_id of current access unit
 +
      uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16]; // FIXME should these be moved down?
      uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
      uint32_t(*dequant4_coeff[6])[16];
      uint8_t field_scan[16];
      uint8_t field_scan8x8[64];
      uint8_t field_scan8x8_cavlc[64];
 -    const uint8_t *zigzag_scan_q0;
 -    const uint8_t *zigzag_scan8x8_q0;
 -    const uint8_t *zigzag_scan8x8_cavlc_q0;
 -    const uint8_t *field_scan_q0;
 -    const uint8_t *field_scan8x8_q0;
 -    const uint8_t *field_scan8x8_cavlc_q0;
 +    uint8_t zigzag_scan_q0[16];
 +    uint8_t zigzag_scan8x8_q0[64];
 +    uint8_t zigzag_scan8x8_cavlc_q0[64];
 +    uint8_t field_scan_q0[16];
 +    uint8_t field_scan8x8_q0[64];
 +    uint8_t field_scan8x8_cavlc_q0[64];
  
      int x264_build;
  
      struct H264Context *thread_context[H264_MAX_THREADS];
  
      /**
 -     * current slice number, used to initalize slice_num of each thread/context
 +     * current slice number, used to initialize slice_num of each thread/context
       */
      int current_slice;
  
      enum AVPictureType pict_type;
  
      int last_slice_type;
 +    unsigned int last_ref_count[2];
      /** @} */
  
      /**
       */
      int sei_recovery_frame_cnt;
  
 +    /**
 +     * Are the SEI recovery points looking valid.
 +     */
 +    int valid_recovery_point;
 +
 +    FPA sei_fpa;
 +
      /**
       * recovery_frame is the frame_num at which the next frame should
       * be fully constructed.
  
      int frame_recovered;    ///< Initial frame has been completely recovered
  
 +    int has_recovery_point;
 +
 +    int missing_fields;
 +
  
      // Timestamp stuff
      int sei_buffering_period_present;   ///< Buffering period SEI flag
  
      int cur_chroma_format_idc;
      uint8_t *bipred_scratchpad;
 +
 +    int16_t slice_row[MAX_SLICES]; ///< to detect when MAX_SLICES is too low
 +
 +    uint8_t parse_history[6];
 +    int parse_history_count;
 +    int parse_last_mb;
      uint8_t *edge_emu_buffer;
      int16_t *dc_val_base;
  
      qpel_mc_func (*qpel_avg)[16];
  } H264Context;
  
 -extern const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM + 1]; ///< One chroma qp table for each supported bit depth (8, 9, 10).
 +extern const uint8_t ff_h264_chroma_qp[7][QP_MAX_NUM + 1]; ///< One chroma qp table for each possible bit depth (8-14).
  extern const uint16_t ff_h264_mb_sizes[4];
  
  /**
@@@ -865,8 -804,8 +865,8 @@@ int ff_h264_check_intra4x4_pred_mode(H2
  int ff_h264_check_intra_pred_mode(H264Context *h, H264SliceContext *sl,
                                    int mode, int is_chroma);
  
- void ff_h264_hl_decode_mb(H264Context *h, H264SliceContext *sl);
+ 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);
  
@@@ -884,7 -823,7 +884,7 @@@ int ff_h264_decode_mb_cabac(H264Contex
  
  void ff_h264_init_cabac_states(H264Context *h, H264SliceContext *sl);
  
 -void h264_init_dequant_tables(H264Context *h);
 +void ff_h264_init_dequant_tables(H264Context *h);
  
  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);
@@@ -905,19 -844,6 +905,19 @@@ void ff_h264_filter_mb(H264Context *h, 
   */
  void ff_h264_reset_sei(H264Context *h);
  
 +/**
 + * Get stereo_mode string from the h264 frame_packing_arrangement
 + * @param h H.264 context.
 + */
 +const char* ff_h264_sei_stereo_mode(H264Context *h);
 +
 +#define COPY_PICTURE(dst, src) \
 +do {\
 +    *(dst) = *(src);\
 +    (dst)->f.extended_data = (dst)->f.data;\
 +    (dst)->tf.f = &(dst)->f;\
 +} while (0)
 +
  /*
   * o-o o-o
   *  / / /
@@@ -968,7 -894,7 +968,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);
@@@ -1124,34 -1050,6 +1124,34 @@@ static av_always_inline int get_dct8x8_
                    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)
 +        return -1;
 +
 +    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 -1;
 +    }
 +    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);
@@@ -1166,9 -1064,6 +1166,9 @@@ int ff_pred_weight_table(H264Context *h
  int ff_set_ref_count(H264Context *h, H264SliceContext *sl);
  
  int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl, H264Context *h0);
 +#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);
@@@ -1177,6 -1072,4 +1177,6 @@@ void ff_h264_flush_change(H264Context *
  
  void ff_h264_free_tables(H264Context *h, int free_rbsp);
  
 +void ff_h264_set_erpic(ERPicture *dst, H264Picture *src);
 +
  #endif /* AVCODEC_H264_H */
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
   */
  
  #include "svq3.h"
  #include "thread.h"
  
- static inline int get_lowest_part_list_y(H264Context *h, H264SliceContext *sl,
+ static inline int get_lowest_part_list_y(H264SliceContext *sl,
                                           H264Picture *pic, 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(H264Context *h, H264SliceContext *sl,
+ 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)
  {
@@@ -68,7 -68,7 +68,7 @@@
          // Fields can wait on each other, though.
          if (ref->tf.progress->data != h->cur_pic.tf.progress->data ||
              (ref->reference & 3) != h->picture_structure) {
-             my = get_lowest_part_list_y(h, sl, ref, n, height, y_offset, 0);
+             my = get_lowest_part_list_y(sl, ref, n, height, y_offset, 0);
              if (refs[0][ref_n] < 0)
                  nrefs[0] += 1;
              refs[0][ref_n] = FFMAX(refs[0][ref_n], my);
@@@ -81,7 -81,7 +81,7 @@@
  
          if (ref->tf.progress->data != h->cur_pic.tf.progress->data ||
              (ref->reference & 3) != h->picture_structure) {
-             my = get_lowest_part_list_y(h, sl, ref, n, height, y_offset, 1);
+             my = get_lowest_part_list_y(sl, ref, n, height, y_offset, 1);
              if (refs[1][ref_n] < 0)
                  nrefs[1] += 1;
              refs[1][ref_n] = FFMAX(refs[1][ref_n], my);
   *
   * @param h the H264 context
   */
- static void await_references(H264Context *h, H264SliceContext *sl)
+ static void await_references(const H264Context *h, H264SliceContext *sl)
  {
      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,
          }
  }
  
- static av_always_inline void mc_dir_part(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void mc_dir_part(const H264Context *h, H264SliceContext *sl,
                                           H264Picture *pic,
                                           int n, int square, int height,
                                           int delta, int list,
                                           uint8_t *dest_y, uint8_t *dest_cb,
                                           uint8_t *dest_cr,
                                           int src_x_offset, int src_y_offset,
-                                          qpel_mc_func *qpix_op,
+                                          const qpel_mc_func *qpix_op,
                                           h264_chroma_mc_func chroma_op,
                                           int pixel_shift, int chroma_idc)
  {
      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->f.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->f.data[1] + ((mx >> 3) << pixel_shift) +
 +    src_cb = pic->f.data[1] + ((mx >> 3) * (1 << pixel_shift)) +
               (my >> ysh) * sl->mb_uvlinesize;
 -    src_cr = pic->f.data[2] + ((mx >> 3) << pixel_shift) +
 +    src_cr = pic->f.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(h->edge_emu_buffer, src_cr,
          src_cr = h->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(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void mc_part_std(const H264Context *h, H264SliceContext *sl,
                                           int n, int square,
                                           int height, int delta,
                                           uint8_t *dest_y, uint8_t *dest_cb,
                                           uint8_t *dest_cr,
                                           int x_offset, int y_offset,
-                                          qpel_mc_func *qpix_put,
+                                          const qpel_mc_func *qpix_put,
                                           h264_chroma_mc_func chroma_put,
-                                          qpel_mc_func *qpix_avg,
+                                          const qpel_mc_func *qpix_avg,
                                           h264_chroma_mc_func chroma_avg,
                                           int list0, int list1,
                                           int pixel_shift, int chroma_idc)
  {
-     qpel_mc_func *qpix_op         = qpix_put;
+     const qpel_mc_func *qpix_op   = qpix_put;
      h264_chroma_mc_func chroma_op = chroma_put;
  
      dest_y += (2 * x_offset << pixel_shift) + 2 * y_offset * sl->mb_linesize;
      }
  }
  
- static av_always_inline void mc_part_weighted(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void mc_part_weighted(const H264Context *h, H264SliceContext *sl,
                                                int n, int square,
                                                int height, int delta,
                                                uint8_t *dest_y, uint8_t *dest_cb,
                                                uint8_t *dest_cr,
                                                int x_offset, int y_offset,
-                                               qpel_mc_func *qpix_put,
+                                               const qpel_mc_func *qpix_put,
                                                h264_chroma_mc_func chroma_put,
                                                h264_weight_func luma_weight_op,
                                                h264_weight_func chroma_weight_op,
              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 & 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->luma_log2_weight_denom,
                              sl->luma_weight[refn1][1][0],
                              sl->luma_weight[refn0][0][1] +
                              sl->luma_weight[refn1][1][1]);
 -            chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize, chroma_height,
 -                              sl->chroma_log2_weight_denom,
 -                              sl->chroma_weight[refn0][0][0][0],
 -                              sl->chroma_weight[refn1][1][0][0],
 -                              sl->chroma_weight[refn0][0][0][1] +
 -                              sl->chroma_weight[refn1][1][0][1]);
 -            chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize, chroma_height,
 -                              sl->chroma_log2_weight_denom,
 -                              sl->chroma_weight[refn0][0][1][0],
 -                              sl->chroma_weight[refn1][1][1][0],
 -                              sl->chroma_weight[refn0][0][1][1] +
 -                              sl->chroma_weight[refn1][1][1][1]);
 +            if (!CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 +                chroma_weight_avg(dest_cb, tmp_cb, sl->mb_uvlinesize, chroma_height,
 +                                  sl->chroma_log2_weight_denom,
 +                                  sl->chroma_weight[refn0][0][0][0],
 +                                  sl->chroma_weight[refn1][1][0][0],
 +                                  sl->chroma_weight[refn0][0][0][1] +
 +                                  sl->chroma_weight[refn1][1][0][1]);
 +                chroma_weight_avg(dest_cr, tmp_cr, sl->mb_uvlinesize, chroma_height,
 +                                  sl->chroma_log2_weight_denom,
 +                                  sl->chroma_weight[refn0][0][1][0],
 +                                  sl->chroma_weight[refn1][1][1][0],
 +                                  sl->chroma_weight[refn0][0][1][1] +
 +                                  sl->chroma_weight[refn1][1][1][1]);
 +            }
          }
      } else {
          int list     = list1 ? 1 : 0;
                         sl->luma_log2_weight_denom,
                         sl->luma_weight[refn][list][0],
                         sl->luma_weight[refn][list][1]);
 -        if (sl->use_weight_chroma) {
 -            chroma_weight_op(dest_cb, sl->mb_uvlinesize, chroma_height,
 -                             sl->chroma_log2_weight_denom,
 -                             sl->chroma_weight[refn][list][0][0],
 -                             sl->chroma_weight[refn][list][0][1]);
 -            chroma_weight_op(dest_cr, sl->mb_uvlinesize, chroma_height,
 -                             sl->chroma_log2_weight_denom,
 -                             sl->chroma_weight[refn][list][1][0],
 -                             sl->chroma_weight[refn][list][1][1]);
 +        if (!CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 +            if (sl->use_weight_chroma) {
 +                chroma_weight_op(dest_cb, sl->mb_uvlinesize, chroma_height,
 +                                 sl->chroma_log2_weight_denom,
 +                                 sl->chroma_weight[refn][list][0][0],
 +                                 sl->chroma_weight[refn][list][0][1]);
 +                chroma_weight_op(dest_cr, sl->mb_uvlinesize, chroma_height,
 +                                 sl->chroma_log2_weight_denom,
 +                                 sl->chroma_weight[refn][list][1][0],
 +                                 sl->chroma_weight[refn][list][1][1]);
 +            }
          }
      }
  }
  
- static av_always_inline void prefetch_motion(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void prefetch_motion(const H264Context *h, H264SliceContext *sl,
                                               int list, int pixel_shift,
                                               int chroma_idc)
  {
          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].f.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, h->linesize, 4);
              h->vdsp.prefetch(src[1] + off, h->linesize, 4);
              h->vdsp.prefetch(src[2] + off, h->linesize, 4);
          } else {
 -            off = ((mx >> 1) << pixel_shift) +
 -                  ((my >> 1) + (sl->mb_x & 7)) * h->uvlinesize +
 -                  (64 << pixel_shift);
 +            off= ((mx>>1)+64) * (1<<pixel_shift) + ((my>>1) + (sl->mb_x&7))*h->uvlinesize;
              h->vdsp.prefetch(src[1] + off, src[2] - src[1], 2);
          }
      }
  }
  
- static av_always_inline void xchg_mb_border(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void xchg_mb_border(const H264Context *h, H264SliceContext *sl,
                                              uint8_t *src_y,
                                              uint8_t *src_cb, uint8_t *src_cr,
                                              int linesize, int uvlinesize,
              XCHG(h->top_borders[top_idx][sl->mb_x + 1],
                   src_y + (17 << pixel_shift), 1);
          }
 -    }
 -    if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 -        if (chroma444) {
 -            if (deblock_top) {
 +        if (simple || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
 +            if (chroma444) {
                  if (deblock_topleft) {
                      XCHG(top_border_m1 + (24 << pixel_shift), src_cb - (7 << pixel_shift), 1);
                      XCHG(top_border_m1 + (40 << pixel_shift), src_cr - (7 << pixel_shift), 1);
                      XCHG(h->top_borders[top_idx][sl->mb_x + 1] + (16 << pixel_shift), src_cb + (17 << pixel_shift), 1);
                      XCHG(h->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);
@@@ -610,7 -610,7 +610,7 @@@ static av_always_inline void dctcoef_se
          AV_WN16A(mb + index, value);
  }
  
- static av_always_inline void hl_decode_mb_predict_luma(H264Context *h,
+ static av_always_inline void hl_decode_mb_predict_luma(const H264Context *h,
                                                         H264SliceContext *sl,
                                                         int mb_type, int is_h264,
                                                         int simple,
                  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) {
 -                    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,
                      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;
      }
  }
  
- static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, H264SliceContext *sl,
+ static av_always_inline void hl_decode_mb_idct_luma(const H264Context *h, H264SliceContext *sl,
                                                      int mb_type,
                                                      int is_h264, int simple,
                                                      int transform_bypass,
  #define SIMPLE 0
  #include "h264_mb_template.c"
  
- void ff_h264_hl_decode_mb(H264Context *h, H264SliceContext *sl)
+ void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
  {
      const int mb_xy   = sl->mb_xy;
      const int mb_type = h->cur_pic.mb_type[mb_xy];
@@@ -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
   */
  
@@@ -40,7 -40,7 +40,7 @@@
  #define CHROMA_IDC 2
  #include "h264_mc_template.c"
  
- static av_noinline void FUNC(hl_decode_mb)(H264Context *h, H264SliceContext *sl)
+ static av_noinline void FUNC(hl_decode_mb)(const H264Context *h, H264SliceContext *sl)
  {
      const int mb_x    = sl->mb_x;
      const int mb_y    = sl->mb_y;
      }
  
      if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
 +        const int bit_depth = h->sps.bit_depth_luma;
          if (PIXEL_SHIFT) {
 -            const int bit_depth = h->sps.bit_depth_luma;
              int j;
              GetBitContext gb;
              init_get_bits(&gb, sl->intra_pcm_ptr,
                  if (!h->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++) {
                  memcpy(dest_y + i * linesize, sl->intra_pcm_ptr + i * 16, 16);
              if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
                  if (!h->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;
  #define CHROMA_IDC 3
  #include "h264_mc_template.c"
  
- static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h, H264SliceContext *sl)
+ static av_noinline void FUNC(hl_decode_mb_444)(const H264Context *h, H264SliceContext *sl)
  {
      const int mb_x    = sl->mb_x;
      const int mb_y    = sl->mb_y;
@@@ -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
   */
  
  #undef  mc_part
  #define mc_part MCFUNC(mc_part)
  
- static void mc_part(H264Context *h, H264SliceContext *sl,
+ static void mc_part(const H264Context *h, H264SliceContext *sl,
                      int n, int square,
                      int height, int delta,
                      uint8_t *dest_y, uint8_t *dest_cb,
                      uint8_t *dest_cr,
                      int x_offset, int y_offset,
-                     qpel_mc_func *qpix_put,
+                     const qpel_mc_func *qpix_put,
                      h264_chroma_mc_func chroma_put,
-                     qpel_mc_func *qpix_avg,
+                     const qpel_mc_func *qpix_avg,
                      h264_chroma_mc_func chroma_avg,
-                     h264_weight_func *weight_op,
-                     h264_biweight_func *weight_avg,
+                     const h264_weight_func *weight_op,
+                     const h264_biweight_func *weight_avg,
                      int list0, int list1)
  {
      if ((sl->use_weight == 2 && list0 && list1 &&
                      chroma_avg, list0, list1, PIXEL_SHIFT, CHROMA_IDC);
  }
  
- static void MCFUNC(hl_motion)(H264Context *h, H264SliceContext *sl,
+ static void MCFUNC(hl_motion)(const H264Context *h, H264SliceContext *sl,
                                uint8_t *dest_y,
                                uint8_t *dest_cb, uint8_t *dest_cr,
                                qpel_mc_func(*qpix_put)[16],
-                               h264_chroma_mc_func(*chroma_put),
+                               const h264_chroma_mc_func(*chroma_put),
                                qpel_mc_func(*qpix_avg)[16],
-                               h264_chroma_mc_func(*chroma_avg),
-                               h264_weight_func *weight_op,
-                               h264_biweight_func *weight_avg)
+                               const h264_chroma_mc_func(*chroma_avg),
+                               const h264_weight_func *weight_op,
+                               const h264_biweight_func *weight_avg)
  {
      const int mb_xy   = sl->mb_xy;
      const int mb_type = h->cur_pic.mb_type[mb_xy];
  
 -    assert(IS_INTER(mb_type));
 +    av_assert2(IS_INTER(mb_type));
  
      if (HAVE_THREADS && (h->avctx->active_thread_type & FF_THREAD_FRAME))
          await_references(h, sl);
      } 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];
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
              } 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_x_offset = x_offset + 2 * (j & 1);
                      int sub_y_offset = y_offset + (j & 2);