Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 21 Oct 2011 23:03:27 +0000 (01:03 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 21 Oct 2011 23:16:41 +0000 (01:16 +0200)
* qatar/master: (35 commits)
  flvdec: Do not call parse_keyframes_index with a NULL stream
  libspeexdec: include system headers before local headers
  libspeexdec: return meaningful error codes
  libspeexdec: cosmetics: reindent
  libspeexdec: decode one frame at a time.
  swscale: fix signed shift overflows in ff_yuv2rgb_c_init_tables()
  Move timefilter code from lavf to lavd.
  mov: add support for hdvd and pgapmetadata atoms
  mov: rename function _stik, some indentation cosmetics
  mov: rename function _int8 to remove ambiguity, some indentation cosmetics
  mov: parse the gnre atom
  mp3on4: check for allocation failures in decode_init_mp3on4()
  mp3on4: create a separate flush function for MP3onMP4.
  mp3on4: ensure that the frame channel count does not exceed the codec channel count.
  mp3on4: set channel layout
  mp3on4: fix the output channel order
  mp3on4: allocate temp buffer with av_malloc() instead of on the stack.
  mp3on4: copy MPADSPContext from first context to all contexts.
  fmtconvert: port float_to_int16_interleave() 2-channel x86 inline asm to yasm
  fmtconvert: port int32_to_float_fmul_scalar() x86 inline asm to yasm
  ...

Conflicts:
libavcodec/arm/h264dsp_init_arm.c
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_ps.c
libavcodec/h264dsp_template.c
libavcodec/h264idct_template.c
libavcodec/h264pred.c
libavcodec/h264pred_template.c
libavcodec/x86/h264dsp_mmx.c
libavdevice/Makefile
libavdevice/jack_audio.c
libavformat/Makefile
libavformat/flvdec.c
libavformat/flvenc.c
libavutil/pixfmt.h
libswscale/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
46 files changed:
1  2 
Changelog
libavcodec/arm/h264dsp_init_arm.c
libavcodec/arm/h264dsp_neon.S
libavcodec/fmtconvert.h
libavcodec/h264.c
libavcodec/h264_cabac.c
libavcodec/h264_ps.c
libavcodec/h264dsp.c
libavcodec/h264dsp.h
libavcodec/h264dsp_template.c
libavcodec/h264idct_template.c
libavcodec/h264pred.c
libavcodec/h264pred_template.c
libavcodec/libspeexdec.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodec_float.c
libavcodec/ppc/h264_altivec.c
libavcodec/utils.c
libavcodec/vp8.c
libavcodec/vp8.h
libavcodec/x86/dsputil_yasm.asm
libavcodec/x86/fmtconvert.asm
libavcodec/x86/fmtconvert_mmx.c
libavcodec/x86/h264_weight.asm
libavcodec/x86/h264dsp_mmx.c
libavdevice/Makefile
libavdevice/alsa-audio.h
libavdevice/jack_audio.c
libavdevice/timefilter.c
libavdevice/timefilter.h
libavformat/Makefile
libavformat/flvdec.c
libavformat/flvenc.c
libavformat/mov.c
libavutil/pixdesc.c
libavutil/pixfmt.h
libavutil/x86/x86util.asm
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/utils.c
libswscale/yuv2rgb.c
tests/ref/lavfi/pixdesc
tests/ref/lavfi/pixfmts_copy
tests/ref/lavfi/pixfmts_null
tests/ref/lavfi/pixfmts_scale
tests/ref/lavfi/pixfmts_vflip

diff --combined Changelog
+++ b/Changelog
@@@ -1,14 -1,12 +1,14 @@@
  Entries are sorted chronologically from oldest to youngest within each release,
  releases are sorted from youngest to oldest.
  
 +version next:
  
 -version <next>:
 +- openal input device added
 +- boxblur filter added
  - BWF muxer
  - Flash Screen Video 2 decoder
 -- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver
 -- ffmpeg deprecated, added avconv, which is almost the same for now, except
 +- lavfi input device added
 +- added avconv, which is almost the same for now, except
  for a few incompatible changes in the options, which will hopefully make them
  easier to use. The changes are:
      * -newvideo/-newaudio/-newsubtitle are gone, because they were redundant and
        '-preset <presetname>'.
      * -intra option was removed, it's equivalent to -g 0.
  - XMV demuxer
 +- LOAS demuxer
 +- ashowinfo filter added
  - Windows Media Image decoder
 +- amovie source added
  - LATM muxer/demuxer
 -- showinfo filter
 -- split filter
 +- Speex encoder via libspeex
 +- JSON output in ffprobe
 +- WTV muxer
 +- Optional C++ Support (needed for libstagefright)
 +- H.264 Decoding on Android via Stagefright
 +- Prores decoder
 +- BIN/XBIN/ADF/IDF text file decoder
 +- aconvert audio filter added
 +- audio support to lavfi input device added
  - libcdio-paranoia input device for audio CD grabbing
 -- select filter
  - Apple ProRes decoder
  - CELT in Ogg demuxing
 +- G.723.1 demuxer and decoder
 +- libmodplug support (--enable-libmodplug)
  - VC-1 interlaced decoding
 -- lut, lutrgb, and lutyuv filters
 -- boxblur filter
 +- libutvideo wrapper (--enable-libutvideo)
 +- aevalsrc audio source added
  - Ut Video decoder
  - Speex encoding via libspeex
+ - 4:2:2 H.264 decoding support
  
  
 -version 0.7:
 -
 -- E-AC-3 audio encoder
 -- ac3enc: add channel coupling support
 -- floating-point sample format support for (E-)AC-3, DCA, AAC, Vorbis decoders
 -- H.264/MPEG frame-level multithreading
 -- av_metadata_* functions renamed to av_dict_* and moved to libavutil
 -- 4:4:4 H.264 decoding support
 -- 10-bit H.264 optimizations for x86
 -- bump libswscale for recently reported ABI break
 +version 0.8:
  
  
 -version 0.7_beta2:
 -
 -- VP8 frame-level multithreading
 -- NEON optimizations for VP8
 -- removed a lot of deprecated API cruft
 -- FFT and IMDCT optimizations for AVX (Sandy Bridge) processors
 -- DPX image encoder
 -- SMPTE 302M AES3 audio decoder
 -- ffmpeg no longer quits after the 'q' key is pressed; use 'ctrl+c' instead
 -- 9bit and 10bit per sample support in the H.264 decoder
 -
 -
 -version 0.7_beta1:
 -
 +- many many things we forgot because we rather write code than changelogs
  - WebM support in Matroska de/muxer
  - low overhead Ogg muxing
  - MMS-TCP support
@@@ -80,7 -90,6 +81,7 @@@
  - Demuxer for On2's IVF format
  - Pictor/PC Paint decoder
  - HE-AAC v2 decoder
 +- HE-AAC v2 encoding with libaacplus
  - libfaad2 wrapper removed
  - DTS-ES extension (XCh) decoding support
  - native VP8 decoder
  - RTP depacketization of QDM2
  - ANSI/ASCII art playback system
  - Lego Mindstorms RSO de/muxer
 +- libavcore added (and subsequently removed)
  - SubRip subtitle file muxer and demuxer
  - Chinese AVS encoding via libxavs
  - ffprobe -show_packets option added
  - replace the ocv_smooth filter with a more generic ocv filter
  - Windows Televison (WTV) demuxer
  - FFmpeg metadata format muxer and demuxer
 -- SubRip (srt) subtitle decoder
 +- SubRip (srt) subtitle encoder and decoder
  - floating-point AC-3 encoder added
  - Lagarith decoder
  - ffmpeg -copytb option added
  - sndio support for playback and record
  - Linux framebuffer input device added
  - Chronomaster DFA decoder
 -- Mobotix MxPEG decoder
 +- DPX image encoder
 +- MicroDVD subtitle file muxer and demuxer
 +- Playstation Portable PMP format demuxer
 +- fieldorder video filter added
  - AAC encoding via libvo-aacenc
  - AMR-WB encoding via libvo-amrwbenc
  - xWMA demuxer
 -- fieldorder video filter added
 +- Mobotix MxPEG decoder
 +- VP8 frame-multithreading
 +- NEON optimizations for VP8
 +- Lots of deprecated API cruft removed
 +- fft and imdct optimizations for AVX (Sandy Bridge) processors
 +- showinfo filter added
 +- SMPTE 302M AES3 audio decoder
 +- Apple Core Audio Format muxer
 +- 9bit and 10bit per sample support in the H.264 decoder
 +- 9bit and 10bit FFV1 encoding / decoding
 +- split filter added
 +- select filter added
 +- sdl output device added
 +- libmpcodecs video filter support (3 times as many filters than before)
 +- mpeg2 aspect ratio dection fixed
 +- libxvid aspect pickiness fixed
 +- Frame multithreaded decoding
 +- E-AC-3 audio encoder
 +- ac3enc: add channel coupling support
 +- floating-point sample format support to the ac3, eac3, dca, aac, and vorbis decoders.
 +- H264/MPEG frame-level multi-threading
 +- All av_metadata_* functions renamed to av_dict_* and moved to libavutil
 +- 4:4:4 H.264 decoding support
 +- 10-bit H.264 optimizations for x86
 +- lut, lutrgb, and lutyuv filters added
 +- buffersink libavfilter sink added
 +- Bump libswscale for recently reported ABI break
 +
 +
 +version 0.7:
 +
 +- all the changes for 0.8, but keeping API/ABI compatibility with the 0.6 release
  
  
  version 0.6:
@@@ -431,7 -405,6 +432,7 @@@ version 0.5
  - Gopher client support
  - MXF D-10 muxer
  - generic metadata API
 +- flash ScreenVideo2 encoder
  
  
  version 0.4.9-pre1:
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2010 Mans Rullgard <mans@mansr.com>
   *
 - * 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,47 -32,22 +32,22 @@@ void ff_h264_v_loop_filter_chroma_neon(
  void ff_h264_h_loop_filter_chroma_neon(uint8_t *pix, int stride, int alpha,
                                         int beta, int8_t *tc0);
  
- void ff_weight_h264_pixels_16x16_neon(uint8_t *ds, int stride, int log2_den,
-                                       int weight, int offset);
- void ff_weight_h264_pixels_16x8_neon(uint8_t *ds, int stride, int log2_den,
-                                      int weight, int offset);
- void ff_weight_h264_pixels_8x16_neon(uint8_t *ds, int stride, int log2_den,
-                                      int weight, int offset);
- void ff_weight_h264_pixels_8x8_neon(uint8_t *ds, int stride, int log2_den,
-                                     int weight, int offset);
- void ff_weight_h264_pixels_8x4_neon(uint8_t *ds, int stride, int log2_den,
-                                     int weight, int offset);
- void ff_weight_h264_pixels_4x8_neon(uint8_t *ds, int stride, int log2_den,
-                                     int weight, int offset);
- void ff_weight_h264_pixels_4x4_neon(uint8_t *ds, int stride, int log2_den,
-                                     int weight, int offset);
- void ff_weight_h264_pixels_4x2_neon(uint8_t *ds, int stride, int log2_den,
-                                     int weight, int offset);
+ void ff_weight_h264_pixels_16_neon(uint8_t *dst, int stride, int height,
+                                    int log2_den, int weight, int offset);
+ void ff_weight_h264_pixels_8_neon(uint8_t *dst, int stride, int height,
+                                   int log2_den, int weight, int offset);
+ void ff_weight_h264_pixels_4_neon(uint8_t *dst, int stride, int height,
+                                   int log2_den, int weight, int offset);
  
- void ff_biweight_h264_pixels_16x16_neon(uint8_t *dst, uint8_t *src, int stride,
-                                         int log2_den, int weightd, int weights,
-                                         int offset);
- void ff_biweight_h264_pixels_16x8_neon(uint8_t *dst, uint8_t *src, int stride,
-                                        int log2_den, int weightd, int weights,
-                                        int offset);
- void ff_biweight_h264_pixels_8x16_neon(uint8_t *dst, uint8_t *src, int stride,
-                                        int log2_den, int weightd, int weights,
-                                        int offset);
- void ff_biweight_h264_pixels_8x8_neon(uint8_t *dst, uint8_t *src, int stride,
-                                       int log2_den, int weightd, int weights,
-                                       int offset);
- void ff_biweight_h264_pixels_8x4_neon(uint8_t *dst, uint8_t *src, int stride,
-                                       int log2_den, int weightd, int weights,
-                                       int offset);
- void ff_biweight_h264_pixels_4x8_neon(uint8_t *dst, uint8_t *src, int stride,
-                                       int log2_den, int weightd, int weights,
-                                       int offset);
- void ff_biweight_h264_pixels_4x4_neon(uint8_t *dst, uint8_t *src, int stride,
-                                       int log2_den, int weightd, int weights,
-                                       int offset);
- void ff_biweight_h264_pixels_4x2_neon(uint8_t *dst, uint8_t *src, int stride,
-                                       int log2_den, int weightd, int weights,
-                                       int offset);
+ void ff_biweight_h264_pixels_16_neon(uint8_t *dst, uint8_t *src, int stride,
+                                      int height, int log2_den, int weightd,
+                                      int weights, int offset);
+ void ff_biweight_h264_pixels_8_neon(uint8_t *dst, uint8_t *src, int stride,
+                                     int height, int log2_den, int weightd,
+                                     int weights, int offset);
+ void ff_biweight_h264_pixels_4_neon(uint8_t *dst, uint8_t *src, int stride,
+                                     int height, int log2_den, int weightd,
+                                     int weights, int offset);
  
  void ff_h264_idct_add_neon(uint8_t *dst, DCTELEM *block, int stride);
  void ff_h264_idct_dc_add_neon(uint8_t *dst, DCTELEM *block, int stride);
@@@ -97,27 -72,16 +72,18 @@@ static void ff_h264dsp_init_neon(H264DS
      if (bit_depth == 8) {
      c->h264_v_loop_filter_luma   = ff_h264_v_loop_filter_luma_neon;
      c->h264_h_loop_filter_luma   = ff_h264_h_loop_filter_luma_neon;
 +    if(chroma_format_idc == 1){
      c->h264_v_loop_filter_chroma = ff_h264_v_loop_filter_chroma_neon;
      c->h264_h_loop_filter_chroma = ff_h264_h_loop_filter_chroma_neon;
-     c->weight_h264_pixels_tab[0] = ff_weight_h264_pixels_16x16_neon;
-     c->weight_h264_pixels_tab[1] = ff_weight_h264_pixels_16x8_neon;
-     c->weight_h264_pixels_tab[2] = ff_weight_h264_pixels_8x16_neon;
-     c->weight_h264_pixels_tab[3] = ff_weight_h264_pixels_8x8_neon;
-     c->weight_h264_pixels_tab[4] = ff_weight_h264_pixels_8x4_neon;
-     c->weight_h264_pixels_tab[5] = ff_weight_h264_pixels_4x8_neon;
-     c->weight_h264_pixels_tab[6] = ff_weight_h264_pixels_4x4_neon;
-     c->weight_h264_pixels_tab[7] = ff_weight_h264_pixels_4x2_neon;
 +    }
  
-     c->biweight_h264_pixels_tab[0] = ff_biweight_h264_pixels_16x16_neon;
-     c->biweight_h264_pixels_tab[1] = ff_biweight_h264_pixels_16x8_neon;
-     c->biweight_h264_pixels_tab[2] = ff_biweight_h264_pixels_8x16_neon;
-     c->biweight_h264_pixels_tab[3] = ff_biweight_h264_pixels_8x8_neon;
-     c->biweight_h264_pixels_tab[4] = ff_biweight_h264_pixels_8x4_neon;
-     c->biweight_h264_pixels_tab[5] = ff_biweight_h264_pixels_4x8_neon;
-     c->biweight_h264_pixels_tab[6] = ff_biweight_h264_pixels_4x4_neon;
-     c->biweight_h264_pixels_tab[7] = ff_biweight_h264_pixels_4x2_neon;
+     c->weight_h264_pixels_tab[0] = ff_weight_h264_pixels_16_neon;
+     c->weight_h264_pixels_tab[1] = ff_weight_h264_pixels_8_neon;
+     c->weight_h264_pixels_tab[2] = ff_weight_h264_pixels_4_neon;
+     c->biweight_h264_pixels_tab[0] = ff_biweight_h264_pixels_16_neon;
+     c->biweight_h264_pixels_tab[1] = ff_biweight_h264_pixels_8_neon;
+     c->biweight_h264_pixels_tab[2] = ff_biweight_h264_pixels_4_neon;
  
      c->h264_idct_add        = ff_h264_idct_add_neon;
      c->h264_idct_dc_add     = ff_h264_idct_dc_add_neon;
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
   *
 - * 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
   */
  
@@@ -1592,7 -1592,7 +1592,7 @@@ endfun
          vdup.8          d1,  r5
          vmov            q2,  q8
          vmov            q3,  q8
- 1:      subs            ip,  ip,  #2
+ 1:      subs            r3,  r3,  #2
          vld1.8          {d20-d21},[r0,:128], r2
          \macd           q2,  d0,  d20
          pld             [r0]
          vdup.8          d1,  r5
          vmov            q1,  q8
          vmov            q10, q8
- 1:      subs            ip,  ip,  #2
+ 1:      subs            r3,  r3,  #2
          vld1.8          {d4},[r0,:64], r2
          \macd           q1,  d0,  d4
          pld             [r0]
          vdup.8          d1,  r5
          vmov            q1,  q8
          vmov            q10, q8
- 1:      subs            ip,  ip,  #4
+ 1:      subs            r3,  r3,  #4
          vld1.32         {d4[0]},[r0,:32], r2
          vld1.32         {d4[1]},[r0,:32], r2
          \macd           q1,  d0,  d4
          .endm
  
          .macro  biweight_func w
- function biweight_h264_pixels_\w\()_neon
+ function ff_biweight_h264_pixels_\w\()_neon, export=1
          push            {r4-r6, lr}
-         add             r4,  sp,  #16
+         ldr             r12, [sp, #16]
+         add             r4,  sp,  #20
          ldm             r4,  {r4-r6}
          lsr             lr,  r4,  #31
          add             r6,  r6,  #1
          eors            lr,  lr,  r5,  lsr #30
          orr             r6,  r6,  #1
-         vdup.16         q9,  r3
-         lsl             r6,  r6,  r3
+         vdup.16         q9,  r12
+         lsl             r6,  r6,  r12
          vmvn            q9,  q9
          vdup.16         q8,  r6
          mov             r6,  r0
  endfunc
          .endm
  
-         .macro  biweight_entry w, h, b=1
- function ff_biweight_h264_pixels_\w\()x\h\()_neon, export=1
-         mov             ip,  #\h
- .if \b
-         b               biweight_h264_pixels_\w\()_neon
- .endif
- endfunc
-         .endm
-         biweight_entry  16, 8
-         biweight_entry  16, 16, b=0
          biweight_func   16
-         biweight_entry  8,  16
-         biweight_entry  8,  4
-         biweight_entry  8,  8,  b=0
          biweight_func   8
-         biweight_entry  4,  8
-         biweight_entry  4,  2
-         biweight_entry  4,  4,  b=0
          biweight_func   4
  
  @ Weighted prediction
  
          .macro  weight_16 add
-         vdup.8          d0,  r3
- 1:      subs            ip,  ip,  #2
+         vdup.8          d0,  r12
+ 1:      subs            r2,  r2,  #2
          vld1.8          {d20-d21},[r0,:128], r1
          vmull.u8        q2,  d0,  d20
          pld             [r0]
          .endm
  
          .macro  weight_8 add
-         vdup.8          d0,  r3
- 1:      subs            ip,  ip,  #2
+         vdup.8          d0,  r12
+ 1:      subs            r2,  r2,  #2
          vld1.8          {d4},[r0,:64], r1
          vmull.u8        q1,  d0,  d4
          pld             [r0]
          .endm
  
          .macro  weight_4 add
-         vdup.8          d0,  r3
+         vdup.8          d0,  r12
          vmov            q1,  q8
          vmov            q10, q8
- 1:      subs            ip,  ip,  #4
+ 1:      subs            r2,  r2,  #4
          vld1.32         {d4[0]},[r0,:32], r1
          vld1.32         {d4[1]},[r0,:32], r1
          vmull.u8        q1,  d0,  d4
          .endm
  
          .macro  weight_func w
- function weight_h264_pixels_\w\()_neon
+ function ff_weight_h264_pixels_\w\()_neon, export=1
          push            {r4, lr}
-         ldr             r4,  [sp, #8]
-         cmp             r2,  #1
-         lsl             r4,  r4,  r2
+         ldr             r12, [sp, #8]
+         ldr             r4,  [sp, #12]
+         cmp             r3,  #1
+         lsl             r4,  r4,  r3
          vdup.16         q8,  r4
          mov             r4,  r0
          ble             20f
-         rsb             lr,  r2,  #1
+         rsb             lr,  r3,  #1
          vdup.16         q9,  lr
-         cmp             r3,  #0
+         cmp             r12, #0
          blt             10f
          weight_\w       vhadd.s16
- 10:     rsb             r3,  r3,  #0
+ 10:     rsb             r12, r12, #0
          weight_\w       vhsub.s16
- 20:     rsb             lr,  r2,  #0
+ 20:     rsb             lr,  r3,  #0
          vdup.16         q9,  lr
-         cmp             r3,  #0
+         cmp             r12, #0
          blt             10f
          weight_\w       vadd.s16
- 10:     rsb             r3,  r3,  #0
+ 10:     rsb             r12, r12, #0
          weight_\w       vsub.s16
  endfunc
          .endm
  
-         .macro  weight_entry w, h, b=1
- function ff_weight_h264_pixels_\w\()x\h\()_neon, export=1
-         mov             ip,  #\h
- .if \b
-         b               weight_h264_pixels_\w\()_neon
- .endif
- endfunc
-         .endm
-         weight_entry    16, 8
-         weight_entry    16, 16, b=0
          weight_func     16
-         weight_entry    8,  16
-         weight_entry    8,  4
-         weight_entry    8,  8,  b=0
          weight_func     8
-         weight_entry    4,  8
-         weight_entry    4,  2
-         weight_entry    4,  4,  b=0
          weight_func     4
diff --combined libavcodec/fmtconvert.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2000, 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -70,7 -70,15 +70,15 @@@ typedef struct FmtConvertContext 
                                        long len, int channels);
  
      /**
-      * Convert an array of interleaved float to multiple arrays of float.
+      * Convert multiple arrays of float to an array of interleaved float.
+      *
+      * @param dst destination array of interleaved float.
+      *            constraints: 16-byte aligned
+      * @param src source array of float arrays, one for each channel.
+      *            constraints: 16-byte aligned
+      * @param len number of elements to convert.
+      *            constraints: multiple of 8
+      * @param channels number of channels
       */
      void (*float_interleave)(float *dst, const float **src, unsigned int len,
                               int channels);
@@@ -85,8 -93,4 +93,8 @@@ void ff_fmt_convert_init_arm(FmtConvert
  void ff_fmt_convert_init_altivec(FmtConvertContext *c, AVCodecContext *avctx);
  void ff_fmt_convert_init_x86(FmtConvertContext *c, AVCodecContext *avctx);
  
 +/* ffdshow custom code */
 +void float_interleave(float *dst, const float **src, long len, int channels);
 +void float_interleave_noscale(float *dst, const float **src, long len, int channels);
 +
  #endif /* AVCODEC_FMTCONVERT_H */
diff --combined libavcodec/h264.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... decoder
   * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -97,9 -97,12 +97,9 @@@ int ff_h264_check_intra4x4_pred_mode(H2
      }
  
      return 0;
 -} //FIXME cleanup like ff_h264_check_intra_pred_mode
 +} //FIXME cleanup like check_intra_pred_mode
  
 -/**
 - * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 - */
 -int ff_h264_check_intra_pred_mode(H264Context *h, int mode){
 +static int check_intra_pred_mode(H264Context *h, int mode, int is_chroma){
      MpegEncContext * const s = &h->s;
      static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1};
      static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8};
  
      if((h->left_samples_available&0x8080) != 0x8080){
          mode= left[ mode ];
 -        if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
 +        if(is_chroma && (h->left_samples_available&0x8080)){ //mad cow disease mode, aka MBAFF + constrained_intra_pred
              mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8);
          }
          if(mode<0){
      return mode;
  }
  
 +/**
 + * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 + */
 +int ff_h264_check_intra16x16_pred_mode(H264Context *h, int mode)
 +{
 +    return check_intra_pred_mode(h, mode, 0);
 +}
 +
 +/**
 + * checks if the top & left blocks are available if needed & changes the dc mode so it only uses the available blocks.
 + */
 +int ff_h264_check_intra_chroma_pred_mode(H264Context *h, int mode)
 +{
 +    return check_intra_pred_mode(h, mode, 1);
 +}
 +
 +
  const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){
      int i, si, di;
      uint8_t *dst;
          i-= RS;
      }
  
 -    if(i>=length-1){ //no escaped 0
 -        *dst_length= length;
 -        *consumed= length+1; //+1 for the header
 -        return src;
 -    }
 -
      bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data
 -    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE);
 +    si=h->rbsp_buffer_size[bufidx];
 +    av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE+MAX_MBPAIR_SIZE);
      dst= h->rbsp_buffer[bufidx];
 +    if(si != h->rbsp_buffer_size[bufidx])
 +        memset(dst + length, 0, FF_INPUT_BUFFER_PADDING_SIZE+MAX_MBPAIR_SIZE);
  
      if (dst == NULL){
          return NULL;
      }
  
 +    if(i>=length-1){ //no escaped 0
 +        *dst_length= length;
 +        *consumed= length+1; //+1 for the header
 +        if(h->s.avctx->flags2 & CODEC_FLAG2_FAST){
 +            return src;
 +        }else{
 +            memcpy(dst, src, length);
 +            return dst;
 +        }
 +    }
 +
  //printf("decoding esc\n");
      memcpy(dst, src, i);
      si=di=i;
@@@ -460,11 -438,14 +460,14 @@@ static void chroma_dc_dct_c(DCTELEM *bl
  }
  #endif
  
- static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_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, h264_chroma_mc_func chroma_op,
-                            int pixel_shift, int chroma444){
+ static av_always_inline void
+ mc_dir_part(H264Context *h, Picture *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, h264_chroma_mc_func chroma_op,
+             int pixel_shift, int chroma_idc)
+ {
      MpegEncContext * const s = &h->s;
      const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8;
      int my=       h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8;
      const int full_my= my>>2;
      const int pic_width  = 16*s->mb_width;
      const int pic_height = 16*s->mb_height >> MB_FIELD;
+     int ysh;
  
      if(mx&7) extra_width -= 3;
      if(my&7) extra_height -= 3;
         || full_my < 0-extra_height
         || full_mx + 16/*FIXME*/ > pic_width + extra_width
         || full_my + 16/*FIXME*/ > pic_height + extra_height){
-         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_y - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
+         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_y - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,
+                                 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height);
              src_y= s->edge_emu_buffer + (2 << pixel_shift) + 2*h->mb_linesize;
          emu=1;
      }
  
      if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return;
  
-     if(chroma444){
+     if(chroma_idc == 3 /* yuv444 */){
          src_cb = pic->f.data[1] + offset;
          if(emu){
              s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb - (2 << pixel_shift) - 2*h->mb_linesize, h->mb_linesize,
          return;
      }
  
-     if(MB_FIELD){
+     ysh = 3 - (chroma_idc == 2 /* yuv422 */);
+     if(chroma_idc == 1 /* yuv420 */ && MB_FIELD){
          // chroma offset when predicting from a field of opposite parity
          my += 2 * ((s->mb_y & 1) - (pic->f.reference - 1));
          emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1);
      }
-     src_cb = pic->f.data[1] + ((mx >> 3) << pixel_shift) + (my >> 3) * h->mb_uvlinesize;
-     src_cr = pic->f.data[2] + ((mx >> 3) << pixel_shift) + (my >> 3) * h->mb_uvlinesize;
+     src_cb = pic->f.data[1] + ((mx >> 3) << pixel_shift) + (my >> ysh) * h->mb_uvlinesize;
+     src_cr = pic->f.data[2] + ((mx >> 3) << pixel_shift) + (my >> ysh) * h->mb_uvlinesize;
  
      if(emu){
-         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
+         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize,
+                                 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),
+                                 pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));
              src_cb= s->edge_emu_buffer;
      }
-     chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7);
+     chroma_op(dest_cb, src_cb, h->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */),
+               mx&7, (my << (chroma_idc == 2 /* yuv422 */)) &7);
  
      if(emu){
-         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1);
+         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize,
+                                 9, 8 * chroma_idc + 1, (mx >> 3), (my >> ysh),
+                                 pic_width >> 1, pic_height >> (chroma_idc == 1 /* yuv420 */));
              src_cr= s->edge_emu_buffer;
      }
-     chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7);
+     chroma_op(dest_cr, src_cr, h->mb_uvlinesize, height >> (chroma_idc == 1 /* yuv420 */),
+               mx&7, (my << (chroma_idc == 2 /* yuv422 */)) &7);
  }
  
- static inline void mc_part_std(H264Context *h, int n, int square, int chroma_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, h264_chroma_mc_func chroma_put,
-                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
-                            int list0, int list1, int pixel_shift, int chroma444){
+ static av_always_inline void
+ mc_part_std(H264Context *h, 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, h264_chroma_mc_func chroma_put,
+             qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
+             int list0, int list1, int pixel_shift, int chroma_idc)
+ {
      MpegEncContext * const s = &h->s;
      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*h->mb_linesize;
-     if(chroma444){
+     if (chroma_idc == 3 /* yuv444 */) {
          dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
          dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
-     }else{
+     } else if (chroma_idc == 2 /* yuv422 */) {
+         dest_cb += (  x_offset << pixel_shift) + 2*y_offset*h->mb_uvlinesize;
+         dest_cr += (  x_offset << pixel_shift) + 2*y_offset*h->mb_uvlinesize;
+     } else /* yuv420 */ {
          dest_cb += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
          dest_cr += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
      }
  
      if(list0){
          Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ];
-         mc_dir_part(h, ref, n, square, chroma_height, delta, 0,
+         mc_dir_part(h, ref, n, square, height, delta, 0,
                             dest_y, dest_cb, dest_cr, x_offset, y_offset,
-                            qpix_op, chroma_op, pixel_shift, chroma444);
+                            qpix_op, chroma_op, pixel_shift, chroma_idc);
  
          qpix_op=  qpix_avg;
          chroma_op= chroma_avg;
  
      if(list1){
          Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ];
-         mc_dir_part(h, ref, n, square, chroma_height, delta, 1,
+         mc_dir_part(h, ref, n, square, height, delta, 1,
                             dest_y, dest_cb, dest_cr, x_offset, y_offset,
-                            qpix_op, chroma_op, pixel_shift, chroma444);
+                            qpix_op, chroma_op, pixel_shift, chroma_idc);
      }
  }
  
- static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_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, h264_chroma_mc_func chroma_put,
-                            h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
-                            h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
-                            int list0, int list1, int pixel_shift, int chroma444){
+ static av_always_inline void
+ mc_part_weighted(H264Context *h, 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, h264_chroma_mc_func chroma_put,
+                  h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op,
+                  h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg,
+                  int list0, int list1, int pixel_shift, int chroma_idc){
      MpegEncContext * const s = &h->s;
+     int chroma_height;
  
      dest_y += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
-     if(chroma444){
+     if (chroma_idc == 3 /* yuv444 */) {
+         chroma_height = height;
          chroma_weight_avg = luma_weight_avg;
          chroma_weight_op = luma_weight_op;
          dest_cb += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
          dest_cr += (2*x_offset << pixel_shift) + 2*y_offset*h->mb_linesize;
-     }else{
+     } else if (chroma_idc == 2 /* yuv422 */) {
+         chroma_height = height;
+         dest_cb += (  x_offset << pixel_shift) + 2*y_offset*h->mb_uvlinesize;
+         dest_cr += (  x_offset << pixel_shift) + 2*y_offset*h->mb_uvlinesize;
+     } else /* yuv420 */ {
+         chroma_height = height >> 1;
          dest_cb += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
          dest_cr += (  x_offset << pixel_shift) +   y_offset*h->mb_uvlinesize;
      }
          int refn0 = h->ref_cache[0][ scan8[n] ];
          int refn1 = h->ref_cache[1][ scan8[n] ];
  
-         mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0,
+         mc_dir_part(h, &h->ref_list[0][refn0], n, square, height, delta, 0,
                      dest_y, dest_cb, dest_cr,
-                     x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);
-         mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1,
+                     x_offset, y_offset, qpix_put, chroma_put,
+                     pixel_shift, chroma_idc);
+         mc_dir_part(h, &h->ref_list[1][refn1], n, square, height, delta, 1,
                      tmp_y, tmp_cb, tmp_cr,
-                     x_offset, y_offset, qpix_put, chroma_put, pixel_shift, chroma444);
+                     x_offset, y_offset, qpix_put, chroma_put,
+                     pixel_shift, chroma_idc);
  
          if(h->use_weight == 2){
              int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1];
              int weight1 = 64 - weight0;
-             luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize, 5, weight0, weight1, 0);
-             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0);
-             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0);
+             luma_weight_avg(  dest_y,  tmp_y,  h->  mb_linesize,
+                               height,        5, weight0, weight1, 0);
+             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize,
+                               chroma_height, 5, weight0, weight1, 0);
+             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize,
+                               chroma_height, 5, weight0, weight1, 0);
          }else{
-             luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom,
+             luma_weight_avg(dest_y, tmp_y, h->mb_linesize, height, h->luma_log2_weight_denom,
                              h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0],
                              h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]);
-             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
+             chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, chroma_height, h->chroma_log2_weight_denom,
                              h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0],
                              h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]);
-             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
+             chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, chroma_height, h->chroma_log2_weight_denom,
                              h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0],
                              h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]);
          }
          int list = list1 ? 1 : 0;
          int refn = h->ref_cache[list][ scan8[n] ];
          Picture *ref= &h->ref_list[list][refn];
-         mc_dir_part(h, ref, n, square, chroma_height, delta, list,
+         mc_dir_part(h, ref, n, square, height, delta, list,
                      dest_y, dest_cb, dest_cr, x_offset, y_offset,
-                     qpix_put, chroma_put, pixel_shift, chroma444);
+                     qpix_put, chroma_put, pixel_shift, chroma_idc);
  
-         luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom,
+         luma_weight_op(dest_y, h->mb_linesize, height, h->luma_log2_weight_denom,
                         h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]);
          if(h->use_weight_chroma){
-             chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom,
+             chroma_weight_op(dest_cb, h->mb_uvlinesize, chroma_height, h->chroma_log2_weight_denom,
                               h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]);
-             chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom,
+             chroma_weight_op(dest_cr, h->mb_uvlinesize, chroma_height, h->chroma_log2_weight_denom,
                               h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]);
          }
      }
  }
  
- static inline void mc_part(H264Context *h, int n, int square, int chroma_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, h264_chroma_mc_func chroma_put,
-                            qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
-                            h264_weight_func *weight_op, h264_biweight_func *weight_avg,
-                            int list0, int list1, int pixel_shift, int chroma444){
+ static av_always_inline void
+ mc_part(H264Context *h, 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, h264_chroma_mc_func chroma_put,
+         qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg,
+         h264_weight_func *weight_op, h264_biweight_func *weight_avg,
+         int list0, int list1, int pixel_shift, int chroma_idc)
+ {
      if((h->use_weight==2 && list0 && list1
          && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32))
         || h->use_weight==1)
-         mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
+         mc_part_weighted(h, n, square, height, delta, dest_y, dest_cb, dest_cr,
                           x_offset, y_offset, qpix_put, chroma_put,
-                          weight_op[0], weight_op[3], weight_avg[0],
-                          weight_avg[3], list0, list1, pixel_shift, chroma444);
+                          weight_op[0], weight_op[1], weight_avg[0],
+                          weight_avg[1], list0, list1, pixel_shift, chroma_idc);
      else
-         mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr,
+         mc_part_std(h, n, square, height, delta, dest_y, dest_cb, dest_cr,
                      x_offset, y_offset, qpix_put, chroma_put, qpix_avg,
-                     chroma_avg, list0, list1, pixel_shift, chroma444);
+                     chroma_avg, list0, list1, pixel_shift, chroma_idc);
  }
  
- static inline void prefetch_motion(H264Context *h, int list, int pixel_shift, int chroma444){
+ static av_always_inline void
+ prefetch_motion(H264Context *h, int list, int pixel_shift, int chroma_idc)
+ {
      /* fetch pixels for estimated mv 4 macroblocks ahead
       * optimized for 64byte cache lines */
      MpegEncContext * const s = &h->s;
          uint8_t **src = h->ref_list[list][refn].f.data;
          int off= (mx << pixel_shift) + (my + (s->mb_x&3)*4)*h->mb_linesize + (64 << pixel_shift);
          s->dsp.prefetch(src[0]+off, s->linesize, 4);
-         if(chroma444){
+         if (chroma_idc == 3 /* yuv444 */) {
              s->dsp.prefetch(src[1]+off, s->linesize, 4);
              s->dsp.prefetch(src[2]+off, s->linesize, 4);
          }else{
 -            off= ((mx>>1) << pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + (64 << pixel_shift);
 +            off= (((mx>>1)+64)<<pixel_shift) + ((my>>1) + (s->mb_x&7))*s->uvlinesize;
              s->dsp.prefetch(src[1]+off, src[2]-src[1], 2);
          }
      }
@@@ -703,7 -716,8 +738,8 @@@ static av_always_inline void hl_motion(
                        qpel_mc_func (*qpix_put)[16], 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,
-                       int pixel_shift, int chroma444){
+                       int pixel_shift, int chroma_idc)
+ {
      MpegEncContext * const s = &h->s;
      const int mb_xy= h->mb_xy;
      const int mb_type = s->current_picture.f.mb_type[mb_xy];
  
      if(HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
          await_references(h);
-     prefetch_motion(h, 0, pixel_shift, chroma444);
+     prefetch_motion(h, 0, pixel_shift, chroma_idc);
  
      if(IS_16X16(mb_type)){
-         mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0,
+         mc_part(h, 0, 1, 16, 0, dest_y, dest_cb, dest_cr, 0, 0,
                  qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
                  weight_op, weight_avg,
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
-                 pixel_shift, chroma444);
+                 pixel_shift, chroma_idc);
      }else if(IS_16X8(mb_type)){
-         mc_part(h, 0, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 0,
+         mc_part(h, 0, 0, 8, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 0,
                  qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
-                 &weight_op[1], &weight_avg[1],
+                 weight_op, weight_avg,
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
-                 pixel_shift, chroma444);
-         mc_part(h, 8, 0, 4, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 4,
+                 pixel_shift, chroma_idc);
+         mc_part(h, 8, 0, 8, 8 << pixel_shift, dest_y, dest_cb, dest_cr, 0, 4,
                  qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
-                 &weight_op[1], &weight_avg[1],
+                 weight_op, weight_avg,
                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),
-                 pixel_shift, chroma444);
+                 pixel_shift, chroma_idc);
      }else if(IS_8X16(mb_type)){
-         mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
+         mc_part(h, 0, 0, 16, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
                  qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
-                 &weight_op[2], &weight_avg[2],
+                 &weight_op[1], &weight_avg[1],
                  IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1),
-                 pixel_shift, chroma444);
-         mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
+                 pixel_shift, chroma_idc);
+         mc_part(h, 4, 0, 16, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
                  qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
-                 &weight_op[2], &weight_avg[2],
+                 &weight_op[1], &weight_avg[1],
                  IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1),
-                 pixel_shift, chroma444);
+                 pixel_shift, chroma_idc);
      }else{
          int i;
  
              int y_offset= (i&2)<<1;
  
              if(IS_SUB_8X8(sub_mb_type)){
-                 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
+                 mc_part(h, n, 1, 8, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset,
                      qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
-                     &weight_op[3], &weight_avg[3],
+                     &weight_op[1], &weight_avg[1],
                      IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                     pixel_shift, chroma444);
+                     pixel_shift, chroma_idc);
              }else if(IS_SUB_8X4(sub_mb_type)){
-                 mc_part(h, n  , 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset,
+                 mc_part(h, n  , 0, 4, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset,
                      qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
-                     &weight_op[4], &weight_avg[4],
+                     &weight_op[1], &weight_avg[1],
                      IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                     pixel_shift, chroma444);
-                 mc_part(h, n+2, 0, 2, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
+                     pixel_shift, chroma_idc);
+                 mc_part(h, n+2, 0, 4, 4 << pixel_shift, dest_y, dest_cb, dest_cr, x_offset, y_offset+2,
                      qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
-                     &weight_op[4], &weight_avg[4],
+                     &weight_op[1], &weight_avg[1],
                      IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                     pixel_shift, chroma444);
+                     pixel_shift, chroma_idc);
              }else if(IS_SUB_4X8(sub_mb_type)){
-                 mc_part(h, n  , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
+                 mc_part(h, n  , 0, 8, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset,
                      qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
-                     &weight_op[5], &weight_avg[5],
+                     &weight_op[2], &weight_avg[2],
                      IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                     pixel_shift, chroma444);
-                 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
+                     pixel_shift, chroma_idc);
+                 mc_part(h, n+1, 0, 8, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset,
                      qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
-                     &weight_op[5], &weight_avg[5],
+                     &weight_op[2], &weight_avg[2],
                      IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                     pixel_shift, chroma444);
+                     pixel_shift, chroma_idc);
              }else{
                  int j;
                  assert(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);
-                     mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
+                     mc_part(h, n+j, 1, 4, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
                          qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
-                         &weight_op[6], &weight_avg[6],
+                         &weight_op[2], &weight_avg[2],
                          IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1),
-                         pixel_shift, chroma444);
+                         pixel_shift, chroma_idc);
                  }
              }
          }
      }
  
-     prefetch_motion(h, 1, pixel_shift, chroma444);
+     prefetch_motion(h, 1, pixel_shift, chroma_idc);
+ }
+ static av_always_inline void
+ hl_motion_420(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
+               qpel_mc_func (*qpix_put)[16], 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,
+               int pixel_shift)
+ {
+     hl_motion(h, dest_y, dest_cb, dest_cr, qpix_put, chroma_put,
+               qpix_avg, chroma_avg, weight_op, weight_avg, pixel_shift, 1);
+ }
+ static av_always_inline void
+ hl_motion_422(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
+               qpel_mc_func (*qpix_put)[16], 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,
+               int pixel_shift)
+ {
+     hl_motion(h, dest_y, dest_cb, dest_cr, qpix_put, chroma_put,
+               qpix_avg, chroma_avg, weight_op, weight_avg, pixel_shift, 2);
  }
  
  static void free_tables(H264Context *h, int free_rbsp){
@@@ -992,39 -1028,30 +1050,39 @@@ static av_cold void common_init(H264Con
      s->height = s->avctx->height;
      s->codec_id= s->avctx->codec->id;
  
 -    ff_h264dsp_init(&h->h264dsp, 8, 1);
 -    ff_h264_pred_init(&h->hpc, s->codec_id, 8, 1);
 +    s->avctx->bits_per_raw_sample = 8;
 +    h->cur_chroma_format_idc = 1;
 +
 +    ff_h264dsp_init(&h->h264dsp,
 +                    s->avctx->bits_per_raw_sample, h->cur_chroma_format_idc);
 +    ff_h264_pred_init(&h->hpc, s->codec_id,
 +                      s->avctx->bits_per_raw_sample, h->cur_chroma_format_idc);
  
      h->dequant_coeff_pps= -1;
      s->unrestricted_mv=1;
      s->decode=1; //FIXME
  
 +    s->dsp.dct_bits = 16;
      dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early
  
      memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t));
      memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t));
  }
  
 -int ff_h264_decode_extradata(H264Context *h)
 +int ff_h264_decode_extradata(H264Context *h, const uint8_t *buf, int size)
  {
      AVCodecContext *avctx = h->s.avctx;
  
 -    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 too short\n");
              return -1;
          }
          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 -1;
              if(decode_nal_units(h, p, nalsize) < 0) {
                  av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i);
          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 -1;
              if (decode_nal_units(h, p, nalsize) < 0) {
                  av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i);
              p += nalsize;
          }
          // Now store right nal length size, that will be use 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;
 -        if(decode_nal_units(h, avctx->extradata, avctx->extradata_size) < 0)
 +        if(decode_nal_units(h, buf, size) < 0)
              return -1;
      }
      return 0;
@@@ -1104,7 -1131,7 +1162,7 @@@ av_cold int ff_h264_decode_init(AVCodec
      }
  
      if(avctx->extradata_size > 0 && avctx->extradata &&
 -        ff_h264_decode_extradata(h))
 +        ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size))
          return -1;
  
      if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){
@@@ -1228,7 -1255,6 +1286,7 @@@ static int decode_update_thread_context
      copy_picture_range(h->delayed_pic, h1->delayed_pic, MAX_DELAYED_PIC_COUNT+2, s, s1);
  
      h->last_slice_type = h1->last_slice_type;
 +    h->sync            = h1->sync;
  
      if(!s->current_picture_ptr) return 0;
  
@@@ -1415,7 -1441,7 +1473,7 @@@ static void decode_postinit(H264Contex
      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->f.reference == 0)
          av_log(s->avctx, AV_LOG_DEBUG, "no picture\n");
      }
  
 +    if (h->next_output_pic && h->next_output_pic->sync) {
 +        h->sync |= 2;
 +    }
 +
      if (setup_finished)
          ff_thread_finish_setup(s->avctx);
  }
  
- static av_always_inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){
+ static av_always_inline void backup_mb_border(H264Context *h, uint8_t *src_y,
+                                               uint8_t *src_cb, uint8_t *src_cr,
+                                               int linesize, int uvlinesize, int simple)
+ {
      MpegEncContext * const s = &h->s;
      uint8_t *top_border;
      int top_idx = 1;
                              AV_COPY128(top_border+16, src_cb + 15*uvlinesize);
                              AV_COPY128(top_border+32, src_cr + 15*uvlinesize);
                          }
 -                    } else if(chroma422) {
 +                    } else if(chroma422){
                          if (pixel_shift) {
                              AV_COPY128(top_border+32, src_cb + 15*uvlinesize);
                              AV_COPY128(top_border+48, src_cr + 15*uvlinesize);
@@@ -1813,7 -1838,8 +1874,8 @@@ static av_always_inline void hl_decode_
      }
  }
  
- static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple, int pixel_shift){
+ static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple, int pixel_shift)
+ {
      MpegEncContext * const s = &h->s;
      const int mb_x= s->mb_x;
      const int mb_y= s->mb_y;
      /* is_h264 should always be true if SVQ3 is disabled. */
      const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264;
      void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
-     const int block_h = 16>>s->chroma_y_shift;
+     const int block_h = 16 >> s->chroma_y_shift;
+     const int chroma422 = CHROMA422;
  
      dest_y  = s->current_picture.f.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
      dest_cb = s->current_picture.f.data[1] + (mb_x << pixel_shift)*8 + mb_y * s->uvlinesize * block_h;
          block_offset = &h->block_offset[48];
          if(mb_y&1){ //FIXME move out of this function?
              dest_y -= s->linesize*15;
-             dest_cb-= s->uvlinesize*(block_h-1);
-             dest_cr-= s->uvlinesize*(block_h-1);
+             dest_cb-= s->uvlinesize * (block_h - 1);
+             dest_cr-= s->uvlinesize * (block_h - 1);
          }
          if(FRAME_MBAFF) {
              int list;
      }
  
      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, (uint8_t*)h->mb, 384*bit_depth);
              }
              if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
                  if (!h->sps.chroma_format_idc) {
-                     for (i = 0; i < 8; i++) {
+                     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);
 +                            tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
                          }
                      }
                  } else {
              }
              if(simple || !CONFIG_GRAY || !(s->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);
++                        memset(dest_cb + i*uvlinesize, 1 << (bit_depth - 1), 8);
++                        memset(dest_cr + i*uvlinesize, 1 << (bit_depth - 1), 8);
                      }
                  } else {
 -                    for (i = 0; i < block_h; i++) {
 +                    for (i=0; i<block_h; i++) {
-                         memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4,  8);
-                         memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4,  8);
+                         memcpy(dest_cb + i*uvlinesize, h->mb + 128 + i*4,  8);
+                         memcpy(dest_cr + i*uvlinesize, h->mb + 160 + i*4,  8);
                      }
                  }
              }
              if(h->deblocking_filter)
                  xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, 0, simple, pixel_shift);
          }else if(is_h264){
-             hl_motion(h, dest_y, dest_cb, dest_cr,
-                       s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
-                       s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
-                       h->h264dsp.weight_h264_pixels_tab,
-                       h->h264dsp.biweight_h264_pixels_tab, pixel_shift, 0);
+             if (chroma422) {
+                 hl_motion_422(h, dest_y, dest_cb, dest_cr,
+                               s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
+                               s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
+                               h->h264dsp.weight_h264_pixels_tab,
+                               h->h264dsp.biweight_h264_pixels_tab,
+                               pixel_shift);
+             } else {
+                 hl_motion_420(h, dest_y, dest_cb, dest_cr,
+                               s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
+                               s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
+                               h->h264dsp.weight_h264_pixels_tab,
+                               h->h264dsp.biweight_h264_pixels_tab,
+                               pixel_shift);
+             }
          }
  
          hl_decode_mb_idct_luma(h, mb_type, is_h264, simple, transform_bypass, pixel_shift, block_offset, linesize, dest_y, 0);
                              if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))
                                  idct_add   (dest[j-1] + block_offset[i], h->mb + (i*16 << pixel_shift), uvlinesize);
                          }
+                         if (chroma422) {
+                             for(i=j*16+4; i<j*16+8; i++){
+                                 if(h->non_zero_count_cache[ scan8[i] ] || dctcoef_get(h->mb, pixel_shift, i*16))
+                                     idct_add   (dest[j-1] + block_offset[i+4], h->mb + (i*16 << pixel_shift), uvlinesize);
+                             }
+                         }
                      }
                  }
              }else{
                  if(is_h264){
                      int qp[2];
-                     if (CHROMA422) {
-                         qp[0] = h->chroma_qp[0]+3;
-                         qp[1] = h->chroma_qp[1]+3;
+                     if (chroma422) {
+                         qp[0] = h->chroma_qp[0] + 3;
+                         qp[1] = h->chroma_qp[1] + 3;
                      } else {
                          qp[0] = h->chroma_qp[0];
                          qp[1] = h->chroma_qp[1];
                      h->h264dsp.h264_idct_add8(dest, block_offset,
                                                h->mb, uvlinesize,
                                                h->non_zero_count_cache);
 -                }else{
 +                }
 +#if CONFIG_SVQ3_DECODER
 +                else{
                      h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*1, h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]);
                      h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16*16*2, h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]);
                      for(j=1; j<3; j++){
                          }
                      }
                  }
 +#endif
              }
          }
      }
@@@ -2086,7 -2131,7 +2165,7 @@@ static av_always_inline void hl_decode_
                        s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
                        s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
                        h->h264dsp.weight_h264_pixels_tab,
-                       h->h264dsp.biweight_h264_pixels_tab, pixel_shift, 1);
+                       h->h264dsp.biweight_h264_pixels_tab, pixel_shift, 3);
          }
  
          for (p = 0; p < plane_count; p++)
@@@ -2285,7 -2330,7 +2364,7 @@@ static void idr(H264Context *h)
  static void flush_dpb(AVCodecContext *avctx){
      H264Context *h= avctx->priv_data;
      int i;
 -    for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) {
 +    for(i=0; i<=MAX_DELAYED_PIC_COUNT; i++) {
          if(h->delayed_pic[i])
              h->delayed_pic[i]->f.reference = 0;
          h->delayed_pic[i]= NULL;
      h->s.first_field= 0;
      ff_h264_reset_sei(h);
      ff_mpeg_flush(avctx);
 +    h->recovery_frame= -1;
 +    h->sync= 0;
  }
  
  static int init_poc(H264Context *h){
@@@ -2628,17 -2671,14 +2707,17 @@@ static int decode_slice_header(H264Cont
  
      if (s->context_initialized
          && (   s->width != s->avctx->width || s->height != s->avctx->height
 +            || s->avctx->bits_per_raw_sample != h->sps.bit_depth_luma
 +            || h->cur_chroma_format_idc != h->sps.chroma_format_idc
              || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) {
          if(h != h0) {
 -            av_log_missing_feature(s->avctx, "Width/height changing with threads is", 0);
 +            av_log_missing_feature(s->avctx, "Width/height/bit depth/chroma idc changing with threads is", 0);
              return -1;   // width / height changed during parallelized decoding
          }
          free_tables(h, 0);
          flush_dpb(s->avctx);
          MPV_common_end(s);
 +        h->list_count = 0;
      }
      if (!s->context_initialized) {
          if (h != h0) {
          s->avctx->sample_aspect_ratio= h->sps.sar;
          av_assert0(s->avctx->sample_aspect_ratio.den);
  
 +        if (s->avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
 +            h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
 +            if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10 &&
 +                (h->sps.bit_depth_luma != 9 || !CHROMA422)) {
 +                s->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
 +                h->cur_chroma_format_idc = h->sps.chroma_format_idc;
 +                h->pixel_shift = h->sps.bit_depth_luma > 8;
 +
 +                ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma, h->sps.chroma_format_idc);
 +                ff_h264_pred_init(&h->hpc, s->codec_id, h->sps.bit_depth_luma, h->sps.chroma_format_idc);
 +                s->dsp.dct_bits = h->sps.bit_depth_luma > 8 ? 32 : 16;
 +                dsputil_init(&s->dsp, s->avctx);
 +            } else {
 +                av_log(s->avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d chroma_idc: %d\n",
 +                       h->sps.bit_depth_luma, h->sps.chroma_format_idc);
 +                return -1;
 +            }
 +        }
 +
          if(h->sps.video_signal_type_present_flag){
 -            s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
 +            s->avctx->color_range = h->sps.full_range>0 ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
              if(h->sps.colour_description_present_flag){
                  s->avctx->color_primaries = h->sps.color_primaries;
                  s->avctx->color_trc       = h->sps.color_trc;
              case 9 :
                  if (CHROMA444)
                      s->avctx->pix_fmt = PIX_FMT_YUV444P9;
+                 else if (CHROMA422)
+                     s->avctx->pix_fmt = PIX_FMT_YUV422P9;
                  else
                      s->avctx->pix_fmt = PIX_FMT_YUV420P9;
                  break;
              default:
                  if (CHROMA444){
                      s->avctx->pix_fmt = s->avctx->color_range == AVCOL_RANGE_JPEG ? PIX_FMT_YUVJ444P : PIX_FMT_YUV444P;
-                 }else if (CHROMA422) {
 +                    if (s->avctx->colorspace == AVCOL_SPC_RGB) {
 +                       s->avctx->pix_fmt = PIX_FMT_GBR24P;
 +                       av_log(h->s.avctx, AV_LOG_DEBUG, "Detected GBR colorspace.\n");
 +                    }
+                 } else if (CHROMA422) {
                      s->avctx->pix_fmt = s->avctx->color_range == AVCOL_RANGE_JPEG ? PIX_FMT_YUVJ422P : PIX_FMT_YUV422P;
                  }else{
                      s->avctx->pix_fmt = s->avctx->get_format(s->avctx,
      if(h->sps.frame_mbs_only_flag){
          s->picture_structure= PICT_FRAME;
      }else{
 +        if(!h->sps.direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B){
 +            av_log(h->s.avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
 +            return -1;
 +        }
          if(get_bits1(&s->gb)) { //field_pic_flag
              s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag
          } else {
      h->ref_count[1]= h->pps.ref_count[1];
  
      if(h->slice_type_nos != AV_PICTURE_TYPE_I){
 +        unsigned max= (16<<(s->picture_structure != PICT_FRAME))-1;
          if(h->slice_type_nos == AV_PICTURE_TYPE_B){
              h->direct_spatial_mv_pred= get_bits1(&s->gb);
          }
              if(h->slice_type_nos==AV_PICTURE_TYPE_B)
                  h->ref_count[1]= get_ue_golomb(&s->gb) + 1;
  
 -            if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){
 -                av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
 -                h->ref_count[0]= h->ref_count[1]= 1;
 -                return -1;
 -            }
 +        }
 +        if(h->ref_count[0]-1 > max || h->ref_count[1]-1 > max){
 +            av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n");
 +            h->ref_count[0]= h->ref_count[1]= 1;
 +            return -1;
          }
          if(h->slice_type_nos == AV_PICTURE_TYPE_B)
              h->list_count= 2;
          else
              h->list_count= 1;
      }else
 -        h->list_count= 0;
 +        h->ref_count[1]= h->ref_count[0]= h->list_count= 0;
  
      if(!default_ref_list_done){
          ff_h264_fill_default_ref_list(h);
  
      h0->last_slice_type = slice_type;
      h->slice_num = ++h0->current_slice;
 -    if(h->slice_num >= MAX_SLICES){
 -        av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n");
 +
 +    if(h->slice_num)
 +        h0->slice_row[(h->slice_num-1)&(MAX_SLICES-1)]= s->resync_mb_y;
 +    if (   h0->slice_row[h->slice_num&(MAX_SLICES-1)] + 3 >= s->resync_mb_y
 +        && h0->slice_row[h->slice_num&(MAX_SLICES-1)] <= s->resync_mb_y
 +        && h->slice_num >= MAX_SLICES) {
 +        //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
 +        av_log(s->avctx, AV_LOG_WARNING, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", h->slice_num, MAX_SLICES);
      }
  
      for(j=0; j<2; j++){
@@@ -3384,7 -3392,7 +3465,7 @@@ static void loop_filter(H264Context *h
      const int end_mb_y= s->mb_y + FRAME_MBAFF;
      const int old_slice_type= h->slice_type;
      const int pixel_shift = h->pixel_shift;
-     const int block_h = 16>>s->chroma_y_shift;
+     const int block_h = 16 >> s->chroma_y_shift;
  
      if(h->deblocking_filter) {
          for(mb_x= start_x; mb_x<end_x; mb_x++){
                  s->mb_x= mb_x;
                  s->mb_y= mb_y;
                  dest_y  = s->current_picture.f.data[0] + ((mb_x << pixel_shift) + mb_y * s->linesize  ) * 16;
-                 dest_cb = s->current_picture.f.data[1] + (mb_x << pixel_shift)*(8<<CHROMA444) + mb_y * s->uvlinesize * block_h;
-                 dest_cr = s->current_picture.f.data[2] + (mb_x << pixel_shift)*(8<<CHROMA444) + mb_y * s->uvlinesize * block_h;
+                 dest_cb = s->current_picture.f.data[1] + (mb_x << pixel_shift) * (8 << CHROMA444) + mb_y * s->uvlinesize * block_h;
+                 dest_cr = s->current_picture.f.data[2] + (mb_x << pixel_shift) * (8 << CHROMA444) + mb_y * s->uvlinesize * block_h;
                      //FIXME simplify above
  
                  if (MB_FIELD) {
                      uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2;
                      if(mb_y&1){ //FIXME move out of this function?
                          dest_y -= s->linesize*15;
-                         dest_cb-= s->uvlinesize*(block_h-1);
-                         dest_cr-= s->uvlinesize*(block_h-1);
+                         dest_cb-= s->uvlinesize * (block_h - 1);
+                         dest_cr-= s->uvlinesize * (block_h - 1);
                      }
                  } else {
                      linesize   = h->mb_linesize   = s->linesize;
@@@ -3588,8 -3596,7 +3669,8 @@@ static int decode_slice(struct AVCodecC
                  if(s->mb_y >= s->mb_height){
                      tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits);
  
 -                    if(get_bits_count(&s->gb) == s->gb.size_in_bits ) {
 +                    if(   get_bits_count(&s->gb) == s->gb.size_in_bits
 +                       || get_bits_count(&s->gb) <  s->gb.size_in_bits && s->avctx->error_recognition < FF_ER_AGGRESSIVE) {
                          ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask);
  
                          return 0;
@@@ -3639,7 -3646,6 +3720,7 @@@ static int execute_decode_slices(H264Co
              hx = h->thread_context[i];
              hx->s.error_recognition = avctx->error_recognition;
              hx->s.error_count = 0;
 +            hx->x264_build= h->x264_build;
          }
  
          avctx->execute(avctx, (void *)decode_slice,
@@@ -3727,13 -3733,13 +3808,13 @@@ static int decode_nal_units(H264Contex
              s->workaround_bugs |= FF_BUG_TRUNCATED;
  
          if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){
 -        while(ptr[dst_length - 1] == 0 && dst_length > 0)
 +        while(dst_length > 0 && ptr[dst_length - 1] == 0)
              dst_length--;
          }
          bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1));
  
          if(s->avctx->debug&FF_DEBUG_STARTCODE){
 -            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length);
 +            av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d/%d at %d/%d length %d\n", hx->nal_unit_type, hx->nal_ref_idc, buf_index, buf_size, dst_length);
          }
  
          if (h->is_avc && (nalsize != consumed) && nalsize){
              if((err = decode_slice_header(hx, h)))
                 break;
  
 +            if (h->sei_recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
 +                h->recovery_frame = (h->frame_num + h->sei_recovery_frame_cnt) %
 +                                    (1 << h->sps.log2_max_frame_num);
 +            }
 +
              s->current_picture_ptr->f.key_frame |=
 -                    (hx->nal_unit_type == NAL_IDR_SLICE) ||
 -                    (h->sei_recovery_frame_cnt >= 0);
 +                    (hx->nal_unit_type == NAL_IDR_SLICE);
 +
 +            if (h->recovery_frame == h->frame_num) {
 +                h->sync |= 1;
 +                h->recovery_frame = -1;
 +            }
 +
 +            h->sync |= !!s->current_picture_ptr->f.key_frame;
 +            h->sync |= 3*!!(s->flags2 & CODEC_FLAG2_SHOW_ALL);
 +            s->current_picture_ptr->sync = h->sync;
  
              if (h->current_slice == 1) {
                  if(!(s->flags2 & CODEC_FLAG2_CHUNKS)) {
              break;
          case NAL_SPS:
              init_get_bits(&s->gb, ptr, bit_length);
 -            ff_h264_decode_seq_parameter_set(h);
 +            if(ff_h264_decode_seq_parameter_set(h) < 0 && h->is_avc && (nalsize != consumed) && nalsize){
 +                av_log(h->s.avctx, AV_LOG_DEBUG, "SPS decoding failure, trying alternative mode\n");
 +                init_get_bits(&s->gb, &buf[buf_index + 1 - consumed], 8*nalsize);
 +                ff_h264_decode_seq_parameter_set(h);
 +            }
  
              if (s->flags& CODEC_FLAG_LOW_DELAY ||
                  (h->sps.bitstream_restriction_flag && !h->sps.num_reorder_frames))
  
              if(avctx->has_b_frames < 2)
                  avctx->has_b_frames= !s->low_delay;
 -
 -            if (avctx->bits_per_raw_sample != h->sps.bit_depth_luma ||
 -                h->cur_chroma_format_idc != h->sps.chroma_format_idc) {
 -                if (h->sps.bit_depth_luma >= 8 && h->sps.bit_depth_luma <= 10) {
 -                    avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
 -                    h->cur_chroma_format_idc = h->sps.chroma_format_idc;
 -                    h->pixel_shift = h->sps.bit_depth_luma > 8;
 -
 -                    ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma, h->sps.chroma_format_idc);
 -                    ff_h264_pred_init(&h->hpc, s->codec_id, h->sps.bit_depth_luma, h->sps.chroma_format_idc);
 -                    s->dsp.dct_bits = h->sps.bit_depth_luma > 8 ? 32 : 16;
 -                    dsputil_init(&s->dsp, s->avctx);
 -                } else {
 -                    av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n", h->sps.bit_depth_luma);
 -                    return -1;
 -                }
 -            }
              break;
          case NAL_PPS:
              init_get_bits(&s->gb, ptr, bit_length);
@@@ -3966,8 -3972,6 +4047,8 @@@ static int decode_frame(AVCodecContext 
  
          return 0;
      }
 +    if(h->is_avc && buf_size >= 9 && AV_RB32(buf)==0x0164001F && buf[5] && buf[8]==0x67)
 +        return ff_h264_decode_extradata(h, buf, buf_size);
  
      buf_index=decode_nal_units(h, buf, buf_size);
      if(buf_index < 0)
  
          field_end(h, 0);
  
 -        if (!h->next_output_pic) {
 -            /* Wait for second field. */
 -            *data_size = 0;
 -
 -        } else {
 -            *data_size = sizeof(AVFrame);
 -            *pict = *(AVFrame*)h->next_output_pic;
 +        *data_size = 0; /* Wait for second field. */
 +        if (h->next_output_pic && h->next_output_pic->sync) {
 +            if(h->sync>1 || h->next_output_pic->f.pict_type != AV_PICTURE_TYPE_B){
 +                *data_size = sizeof(AVFrame);
 +                *pict = *(AVFrame*)h->next_output_pic;
 +            }
          }
      }
  
@@@ -4031,7 -4036,6 +4112,7 @@@ static inline void fill_mb_avail(H264Co
  #undef random
  #define COUNT 8000
  #define SIZE (COUNT*40)
 +extern AVCodec ff_h264_decoder;
  int main(void){
      int i;
      uint8_t temp[SIZE];
      DSPContext dsp;
      AVCodecContext avctx;
  
 +    avcodec_get_context_defaults3(&avctx, &ff_h264_decoder);
 +
      dsputil_init(&dsp, &avctx);
  
      init_put_bits(&pb, temp, SIZE);
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
   */
  
@@@ -1565,7 -1565,12 +1565,12 @@@ DECLARE_ASM_CONST(1, uint8_t, last_coef
      5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8
  };
  
- static av_always_inline void decode_cabac_residual_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff, int is_dc ) {
+ static av_always_inline void
+ decode_cabac_residual_internal(H264Context *h, DCTELEM *block,
+                                int cat, int n, const uint8_t *scantable,
+                                const uint32_t *qmul, int max_coeff,
+                                int is_dc, int chroma422)
+ {
      static const int significant_coeff_flag_offset[2][14] = {
        { 105+0, 105+15, 105+29, 105+44, 105+47, 402, 484+0, 484+15, 484+29, 660, 528+0, 528+15, 528+29, 718 },
        { 277+0, 277+15, 277+29, 277+44, 277+47, 436, 776+0, 776+15, 776+29, 675, 820+0, 820+15, 820+29, 733 }
       * map node ctx => cabac ctx for level=1 */
      static const uint8_t coeff_abs_level1_ctx[8] = { 1, 2, 3, 4, 0, 0, 0, 0 };
      /* map node ctx => cabac ctx for level>1 */
-     static const uint8_t coeff_abs_levelgt1_ctx[8] = { 5, 5, 5, 5, 6, 7, 8, 9 };
+     static const uint8_t coeff_abs_levelgt1_ctx[2][8] = {
+         { 5, 5, 5, 5, 6, 7, 8, 9 },
+         { 5, 5, 5, 5, 6, 7, 8, 8 }, // 422/dc case
+     };
      static const uint8_t coeff_abs_level_transition[2][8] = {
      /* update node ctx after decoding a level=1 */
          { 1, 2, 3, 3, 4, 5, 6, 7 },
          coeff_count= decode_significance_8x8_x86(CC, significant_coeff_ctx_base, index,
                                                   last_coeff_ctx_base, sig_off);
      } else {
-         if (is_dc && max_coeff == 8) { // dc 422
+         if (is_dc && chroma422) { // dc 422
              DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);
          } else {
              coeff_count= decode_significance_x86(CC, max_coeff, significant_coeff_ctx_base, index,
  #else
          DECODE_SIGNIFICANCE( 63, sig_off[last], last_coeff_flag_offset_8x8[last] );
      } else {
-         if (is_dc && max_coeff == 8) { // dc 422
+         if (is_dc && chroma422) { // dc 422
              DECODE_SIGNIFICANCE(7, sig_coeff_offset_dc[last], sig_coeff_offset_dc[last]);
          } else {
              DECODE_SIGNIFICANCE(max_coeff - 1, last, last);
          }
      }
  
 +
  #define STORE_BLOCK(type) \
      do { \
          uint8_t *ctx = coeff_abs_level1_ctx[node_ctx] + abs_level_m1_ctx_base; \
              } \
          } else { \
              int coeff_abs = 2; \
-             if (is_dc && max_coeff == 8) \
-                 node_ctx = FFMIN(node_ctx, 6); \
-             ctx = coeff_abs_levelgt1_ctx[node_ctx] + abs_level_m1_ctx_base; \
+             ctx = coeff_abs_levelgt1_ctx[is_dc && chroma422][node_ctx] + abs_level_m1_ctx_base; \
              node_ctx = coeff_abs_level_transition[1][node_ctx]; \
  \
              while( coeff_abs < 15 && get_cabac( CC, ctx ) ) { \
          } \
      } while ( coeff_count );
  
 -    if (h->pixel_shift) {
 -        STORE_BLOCK(int32_t)
 -    } else {
 -        STORE_BLOCK(int16_t)
 -    }
 +        if (h->pixel_shift) {
 +            STORE_BLOCK(int32_t)
 +        } else {
 +            STORE_BLOCK(int16_t)
 +        }
  #ifdef CABAC_ON_STACK
              h->cabac.range     = cc.range     ;
              h->cabac.low       = cc.low       ;
  }
  
  static void decode_cabac_residual_dc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, int max_coeff ) {
-     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1);
+     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1, 0);
+ }
+ static void decode_cabac_residual_dc_internal_422(H264Context *h, DCTELEM *block,
+                                                   int cat, int n, const uint8_t *scantable,
+                                                   int max_coeff)
+ {
+     decode_cabac_residual_internal(h, block, cat, n, scantable, NULL, max_coeff, 1, 1);
  }
  
  static void decode_cabac_residual_nondc_internal( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
-     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0);
+     decode_cabac_residual_internal(h, block, cat, n, scantable, qmul, max_coeff, 0, 0);
  }
  
  /* cat: 0-> DC 16x16  n = 0
@@@ -1773,6 -1785,19 +1786,19 @@@ static av_always_inline void decode_cab
      decode_cabac_residual_dc_internal( h, block, cat, n, scantable, max_coeff );
  }
  
+ static av_always_inline void
+ decode_cabac_residual_dc_422(H264Context *h, DCTELEM *block,
+                              int cat, int n, const uint8_t *scantable,
+                              int max_coeff)
+ {
+     /* read coded block flag */
+     if (get_cabac(&h->cabac, &h->cabac_state[get_cabac_cbf_ctx(h, cat, n, max_coeff, 1)]) == 0) {
+         h->non_zero_count_cache[scan8[n]] = 0;
+         return;
+     }
+     decode_cabac_residual_dc_internal_422(h, block, cat, n, scantable, max_coeff);
+ }
  static av_always_inline void decode_cabac_residual_nondc( H264Context *h, DCTELEM *block, int cat, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff ) {
      /* read coded block flag */
      if( (cat != 5 || CHROMA444) && get_cabac( &h->cabac, &h->cabac_state[get_cabac_cbf_ctx( h, cat, n, max_coeff, 0 ) ] ) == 0 ) {
@@@ -2013,14 -2038,14 +2039,14 @@@ decode_intra_mb
              write_back_intra_pred_mode(h);
              if( ff_h264_check_intra4x4_pred_mode(h) < 0 ) return -1;
          } else {
 -            h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode( h, h->intra16x16_pred_mode );
 +            h->intra16x16_pred_mode= ff_h264_check_intra16x16_pred_mode( h, h->intra16x16_pred_mode );
              if( h->intra16x16_pred_mode < 0 ) return -1;
          }
          if(decode_chroma){
              h->chroma_pred_mode_table[mb_xy] =
              pred_mode                        = decode_cabac_mb_chroma_pre_mode( h );
  
 -            pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode );
 +            pred_mode= ff_h264_check_intra_chroma_pred_mode( h, pred_mode );
              if( pred_mode < 0 ) return -1;
              h->chroma_pred_mode= pred_mode;
          } else {
          if(CHROMA444){
              decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 1);
              decode_cabac_luma_residual(h, scan, scan8x8, pixel_shift, mb_type, cbp, 2);
-         } else {
-             const int num_c8x8 = h->sps.chroma_format_idc;
+         } else if (CHROMA422) {
              if( cbp&0x30 ){
                  int c;
                  for( c = 0; c < 2; c++ ) {
                      //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
-                     decode_cabac_residual_dc(h, h->mb + ((256 + 16*16*c) << pixel_shift), 3,
-                                              CHROMA_DC_BLOCK_INDEX+c,
-                                              CHROMA422 ? chroma422_dc_scan : chroma_dc_scan,
-                                              4*num_c8x8);
+                     decode_cabac_residual_dc_422(h, h->mb + ((256 + 16*16*c) << pixel_shift), 3,
+                                                  CHROMA_DC_BLOCK_INDEX + c,
+                                                  chroma422_dc_scan, 8);
                  }
              }
  
                  for( c = 0; c < 2; c++ ) {
                      DCTELEM *mb = h->mb + (16*(16 + 16*c) << pixel_shift);
                      qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
-                     for (i8x8 = 0; i8x8 < num_c8x8; i8x8++) {
+                     for (i8x8 = 0; i8x8 < 2; i8x8++) {
                          for (i = 0; i < 4; i++) {
                              const int index = 16 + 16 * c + 8*i8x8 + i;
                              //av_log(s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16);
                  fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
                  fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
              }
+         } else /* yuv420 */ {
+             if( cbp&0x30 ){
+                 int c;
+                 for( c = 0; c < 2; c++ ) {
+                     //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-DC\n",c );
+                     decode_cabac_residual_dc(h, h->mb + ((256 + 16*16*c) << pixel_shift), 3, CHROMA_DC_BLOCK_INDEX+c, chroma_dc_scan, 4);
+                 }
+             }
+             if( cbp&0x20 ) {
+                 int c, i;
+                 for( c = 0; c < 2; c++ ) {
+                     qmul = h->dequant4_coeff[c+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[c]];
+                     for( i = 0; i < 4; i++ ) {
+                         const int index = 16 + 16 * c + i;
+                         //av_log( s->avctx, AV_LOG_ERROR, "INTRA C%d-AC %d\n",c, index - 16 );
+                         decode_cabac_residual_nondc(h, h->mb + (16*index << pixel_shift), 4, index, scan + 1, qmul, 15);
+                     }
+                 }
+             } else {
+                 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
+                 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
+             }
          }
      } else {
          fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
diff --combined libavcodec/h264_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
   */
  
@@@ -70,7 -70,7 +70,7 @@@ static const AVRational pixel_aspect[17
      QP(37,d), QP(37,d), QP(37,d), QP(38,d), QP(38,d), QP(38,d),\
      QP(39,d), QP(39,d), QP(39,d), QP(39,d)
  
 -const uint8_t ff_h264_chroma_qp[3][QP_MAX_NUM+1] = {
 +const uint8_t ff_h264_chroma_qp[5][QP_MAX_NUM+1] = {
      {
          CHROMA_QP_TABLE_END(8)
      },
          6, 7, 8, 9, 10, 11,
          CHROMA_QP_TABLE_END(10)
      },
 +    {
 +        0,  1, 2, 3,  4,  5,
 +        6,  7, 8, 9, 10, 11,
 +        12,13,14,15, 16, 17,
 +        CHROMA_QP_TABLE_END(11)
 +    },
 +    {
 +        0,  1, 2, 3,  4,  5,
 +        6,  7, 8, 9, 10, 11,
 +        12,13,14,15, 16, 17,
 +        18,19,20,21, 22, 23,
 +        CHROMA_QP_TABLE_END(12)
 +    },
  };
  
  static const uint8_t default_scaling4[2][16]={
@@@ -241,6 -228,7 +241,6 @@@ static inline int decode_vui_parameters
          get_ue_golomb(&s->gb); /*max_dec_frame_buffering*/
  
          if(s->gb.size_in_bits < get_bits_count(&s->gb)){
 -            av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
              sps->num_reorder_frames=0;
              sps->bitstream_restriction_flag= 0;
          }
              return -1;
          }
      }
 +    if(s->gb.size_in_bits < get_bits_count(&s->gb)){
 +        av_log(h->s.avctx, AV_LOG_ERROR, "Overread VUI by %d bits\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
 +        return -1;
 +    }
  
      return 0;
  }
@@@ -338,12 -322,10 +338,12 @@@ int ff_h264_decode_seq_parameter_set(H2
      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->chroma_format_idc= get_ue_golomb_31(&s->gb);
              sps->residual_color_transform_flag = get_bits1(&s->gb);
          sps->bit_depth_luma   = get_ue_golomb(&s->gb) + 8;
          sps->bit_depth_chroma = get_ue_golomb(&s->gb) + 8;
 +        if (sps->bit_depth_luma > 12U || sps->bit_depth_chroma > 12U) {
 +            av_log(h->s.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(&s->gb);
          decode_scaling_matrices(h, sps, NULL, 1, sps->scaling_matrix4, sps->scaling_matrix8);
      }else{
      }
  
      sps->ref_frame_count= get_ue_golomb_31(&s->gb);
 -    if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count >= 32U){
 +    if(sps->ref_frame_count > MAX_PICTURE_COUNT-2 || sps->ref_frame_count > 16U){
          av_log(h->s.avctx, AV_LOG_ERROR, "too many reference frames\n");
          goto fail;
      }
          sps->mb_aff= 0;
  
      sps->direct_8x8_inference_flag= get_bits1(&s->gb);
 -    if(!sps->frame_mbs_only_flag && !sps->direct_8x8_inference_flag){
 -        av_log(h->s.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)
  #endif
      sps->crop= get_bits1(&s->gb);
      if(sps->crop){
-         int crop_vertical_limit = sps->chroma_format_idc & 2 ? 16 : 8;
+         int crop_vertical_limit   = sps->chroma_format_idc  & 2 ? 16 : 8;
          int crop_horizontal_limit = sps->chroma_format_idc == 3 ? 16 : 8;
          sps->crop_left  = get_ue_golomb(&s->gb);
          sps->crop_right = get_ue_golomb(&s->gb);
          sps->crop_top   = get_ue_golomb(&s->gb);
          sps->crop_bottom= get_ue_golomb(&s->gb);
          if(sps->crop_left || sps->crop_top){
 -            av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ...\n");
 +            av_log(h->s.avctx, AV_LOG_ERROR, "insane cropping not completely supported, this could look slightly wrong ... (left: %d, top: %d)\n", sps->crop_left, sps->crop_top);
          }
          if(sps->crop_right >= crop_horizontal_limit || sps->crop_bottom >= crop_vertical_limit){
 -            av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, this could look slightly wrong ...\n");
 +            av_log(h->s.avctx, AV_LOG_ERROR, "brainfart cropping not supported, cropping disabled (right: %d, bottom: %d)\n", sps->crop_right, sps->crop_bottom);
 +        /* It is very unlikely that partial cropping will make anybody happy.
 +         * Not cropping at all fixes for example playback of Sisvel 3D streams
 +         * in applications supporting Sisvel 3D. */
 +        sps->crop_left  =
 +        sps->crop_right =
 +        sps->crop_top   =
 +        sps->crop_bottom= 0;
          }
      }else{
          sps->crop_left  =
          sps->sar.den= 1;
  
      if(s->avctx->debug&FF_DEBUG_PICT_INFO){
 -        av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d\n",
 +        av_log(h->s.avctx, AV_LOG_DEBUG, "sps:%u profile:%d/%d poc:%d ref:%d %dx%d %s %s crop:%d/%d/%d/%d %s %s %d/%d b%d\n",
                 sps_id, sps->profile_idc, sps->level_idc,
                 sps->poc_type,
                 sps->ref_frame_count,
                 sps->vui_parameters_present_flag ? "VUI" : "",
                 ((const char*[]){"Gray","420","422","444"})[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
                 );
      }
  
@@@ -568,7 -541,8 +568,7 @@@ int ff_h264_decode_picture_parameter_se
      memcpy(pps->scaling_matrix8, h->sps_buffers[pps->sps_id]->scaling_matrix8, sizeof(pps->scaling_matrix8));
  
      bits_left = bit_length - get_bits_count(&s->gb);
 -    if (bits_left && (bits_left > 8 ||
 -                      show_bits(&s->gb, bits_left) != 1 << (bits_left - 1))) {
 +    if(get_bits_count(&s->gb) < bit_length){
          pps->transform_8x8_mode= get_bits1(&s->gb);
          decode_scaling_matrices(h, h->sps_buffers[pps->sps_id], pps, 0, pps->scaling_matrix4, pps->scaling_matrix8);
          pps->chroma_qp_index_offset[1]= get_se_golomb(&s->gb); //second_chroma_qp_index_offset
diff --combined libavcodec/h264dsp.c
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   * Copyright (c) 2003-2010 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
   */
  
@@@ -64,26 -64,14 +64,14 @@@ void ff_h264dsp_init(H264DSPContext *c
      else\
          c->h264_chroma_dc_dequant_idct= FUNC(ff_h264_chroma422_dc_dequant_idct, depth);\
  \
-     c->weight_h264_pixels_tab[0]= FUNC(weight_h264_pixels16x16, depth);\
-     c->weight_h264_pixels_tab[1]= FUNC(weight_h264_pixels16x8, depth);\
-     c->weight_h264_pixels_tab[2]= FUNC(weight_h264_pixels8x16, depth);\
-     c->weight_h264_pixels_tab[3]= FUNC(weight_h264_pixels8x8, depth);\
-     c->weight_h264_pixels_tab[4]= FUNC(weight_h264_pixels8x4, depth);\
-     c->weight_h264_pixels_tab[5]= FUNC(weight_h264_pixels4x8, depth);\
-     c->weight_h264_pixels_tab[6]= FUNC(weight_h264_pixels4x4, depth);\
-     c->weight_h264_pixels_tab[7]= FUNC(weight_h264_pixels4x2, depth);\
-     c->weight_h264_pixels_tab[8]= FUNC(weight_h264_pixels2x4, depth);\
-     c->weight_h264_pixels_tab[9]= FUNC(weight_h264_pixels2x2, depth);\
-     c->biweight_h264_pixels_tab[0]= FUNC(biweight_h264_pixels16x16, depth);\
-     c->biweight_h264_pixels_tab[1]= FUNC(biweight_h264_pixels16x8, depth);\
-     c->biweight_h264_pixels_tab[2]= FUNC(biweight_h264_pixels8x16, depth);\
-     c->biweight_h264_pixels_tab[3]= FUNC(biweight_h264_pixels8x8, depth);\
-     c->biweight_h264_pixels_tab[4]= FUNC(biweight_h264_pixels8x4, depth);\
-     c->biweight_h264_pixels_tab[5]= FUNC(biweight_h264_pixels4x8, depth);\
-     c->biweight_h264_pixels_tab[6]= FUNC(biweight_h264_pixels4x4, depth);\
-     c->biweight_h264_pixels_tab[7]= FUNC(biweight_h264_pixels4x2, depth);\
-     c->biweight_h264_pixels_tab[8]= FUNC(biweight_h264_pixels2x4, depth);\
-     c->biweight_h264_pixels_tab[9]= FUNC(biweight_h264_pixels2x2, depth);\
+     c->weight_h264_pixels_tab[0]= FUNC(weight_h264_pixels16, depth);\
+     c->weight_h264_pixels_tab[1]= FUNC(weight_h264_pixels8, depth);\
+     c->weight_h264_pixels_tab[2]= FUNC(weight_h264_pixels4, depth);\
+     c->weight_h264_pixels_tab[3]= FUNC(weight_h264_pixels2, depth);\
+     c->biweight_h264_pixels_tab[0]= FUNC(biweight_h264_pixels16, depth);\
+     c->biweight_h264_pixels_tab[1]= FUNC(biweight_h264_pixels8, depth);\
+     c->biweight_h264_pixels_tab[2]= FUNC(biweight_h264_pixels4, depth);\
+     c->biweight_h264_pixels_tab[3]= FUNC(biweight_h264_pixels2, depth);\
  \
      c->h264_v_loop_filter_luma= FUNC(h264_v_loop_filter_luma, depth);\
      c->h264_h_loop_filter_luma= FUNC(h264_h_loop_filter_luma, depth);\
diff --combined libavcodec/h264dsp.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2003-2010 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 "dsputil.h"
  
  //typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
- typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset);
- typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset);
+ typedef void (*h264_weight_func)(uint8_t *block, int stride, int height,
+                                  int log2_denom, int weight, int offset);
+ typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int height,
+                                    int log2_denom, int weightd, int weights, int offset);
  
  /**
   * Context for storing H.264 DSP functions
   */
  typedef struct H264DSPContext{
      /* weighted MC */
-     h264_weight_func weight_h264_pixels_tab[10];
-     h264_biweight_func biweight_h264_pixels_tab[10];
+     h264_weight_func weight_h264_pixels_tab[4];
+     h264_biweight_func biweight_h264_pixels_tab[4];
  
      /* loop filter */
      void (*h264_v_loop_filter_luma)(uint8_t *pix/*align 16*/, int stride, int alpha, int beta, int8_t *tc0);
@@@ -1,21 -1,21 +1,21 @@@
  /*
   * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
 - * Copyright (c) 2003-2010 Michael Niedermayer <michaelni@gmx.at>
 + * Copyright (c) 2003-2011 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 op_scale1(x)  block[x] = av_clip_pixel( (block[x]*weight + offset) >> log2_denom )
  #define op_scale2(x)  dst[x] = av_clip_pixel( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
- #define H264_WEIGHT(W,H) \
- static void FUNCC(weight_h264_pixels ## W ## x ## H)(uint8_t *p_block, int stride, int log2_denom, int weight, int offset){ \
+ #define H264_WEIGHT(W) \
+ static void FUNCC(weight_h264_pixels ## W)(uint8_t *_block, int stride, int height, \
+                                            int log2_denom, int weight, int offset) \
+ { \
      int y; \
-     pixel *block = (pixel*)p_block; \
+     pixel *block = (pixel*)_block; \
 -    stride /= sizeof(pixel); \
 +    stride >>= sizeof(pixel)-1; \
      offset <<= (log2_denom + (BIT_DEPTH-8)); \
      if(log2_denom) offset += 1<<(log2_denom-1); \
-     for(y=0; y<H; y++, block += stride){ \
+     for (y = 0; y < height; y++, block += stride) { \
          op_scale1(0); \
          op_scale1(1); \
          if(W==2) continue; \
          op_scale1(15); \
      } \
  } \
- static void FUNCC(biweight_h264_pixels ## W ## x ## H)(uint8_t *_dst, uint8_t *_src, int stride, int log2_denom, int weightd, int weights, int offset){ \
+ static void FUNCC(biweight_h264_pixels ## W)(uint8_t *_dst, uint8_t *_src, int stride, int height, \
+                                              int log2_denom, int weightd, int weights, int offset) \
+ { \
      int y; \
      pixel *dst = (pixel*)_dst; \
      pixel *src = (pixel*)_src; \
 -    stride /= sizeof(pixel); \
 +    stride >>= sizeof(pixel)-1; \
      offset <<= (BIT_DEPTH-8); \
      offset = ((offset + 1) | 1) << log2_denom; \
-     for(y=0; y<H; y++, dst += stride, src += stride){ \
+     for (y = 0; y < height; y++, dst += stride, src += stride) { \
          op_scale2(0); \
          op_scale2(1); \
          if(W==2) continue; \
      } \
  }
  
- H264_WEIGHT(16,16)
- H264_WEIGHT(16,8)
- H264_WEIGHT(8,16)
- H264_WEIGHT(8,8)
- H264_WEIGHT(8,4)
- H264_WEIGHT(4,8)
- H264_WEIGHT(4,4)
- H264_WEIGHT(4,2)
- H264_WEIGHT(2,4)
- H264_WEIGHT(2,2)
+ H264_WEIGHT(16)
+ H264_WEIGHT(8)
+ H264_WEIGHT(4)
+ H264_WEIGHT(2)
  
  #undef op_scale1
  #undef op_scale2
  #undef H264_WEIGHT
  
 -static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
 +static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
  {
 -    pixel *pix = (pixel*)_pix;
 +    pixel *pix = (pixel*)p_pix;
      int i, d;
 -    xstride /= sizeof(pixel);
 -    ystride /= sizeof(pixel);
 +    xstride >>= sizeof(pixel)-1;
 +    ystride >>= sizeof(pixel)-1;
      alpha <<= BIT_DEPTH - 8;
      beta  <<= BIT_DEPTH - 8;
      for( i = 0; i < 4; i++ ) {
@@@ -164,12 -162,12 +162,12 @@@ static void FUNCC(h264_h_loop_filter_lu
      FUNCC(h264_loop_filter_luma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
  }
  
 -static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
 +static av_always_inline av_flatten void FUNCC(h264_loop_filter_luma_intra)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
  {
 -    pixel *pix = (pixel*)_pix;
 +    pixel *pix = (pixel*)p_pix;
      int d;
 -    xstride /= sizeof(pixel);
 -    ystride /= sizeof(pixel);
 +    xstride >>= sizeof(pixel)-1;
 +    ystride >>= sizeof(pixel)-1;
      alpha <<= BIT_DEPTH - 8;
      beta  <<= BIT_DEPTH - 8;
      for( d = 0; d < 4 * inner_iters; d++ ) {
@@@ -230,14 -228,14 +228,14 @@@ static void FUNCC(h264_h_loop_filter_lu
      FUNCC(h264_loop_filter_luma_intra)(pix, sizeof(pixel), stride, 2, alpha, beta);
  }
  
 -static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
 +static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta, int8_t *tc0)
  {
 -    pixel *pix = (pixel*)_pix;
 +    pixel *pix = (pixel*)p_pix;
      int i, d;
 -    xstride /= sizeof(pixel);
 -    ystride /= sizeof(pixel);
      alpha <<= BIT_DEPTH - 8;
      beta  <<= BIT_DEPTH - 8;
 +    xstride >>= sizeof(pixel)-1;
 +    ystride >>= sizeof(pixel)-1;
      for( i = 0; i < 4; i++ ) {
          const int tc = ((tc0[i] - 1) << (BIT_DEPTH - 8)) + 1;
          if( tc <= 0 ) {
@@@ -284,12 -282,12 +282,12 @@@ static void FUNCC(h264_h_loop_filter_ch
      FUNCC(h264_loop_filter_chroma)(pix, sizeof(pixel), stride, 2, alpha, beta, tc0);
  }
  
 -static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
 +static av_always_inline av_flatten void FUNCC(h264_loop_filter_chroma_intra)(uint8_t *p_pix, int xstride, int ystride, int inner_iters, int alpha, int beta)
  {
 -    pixel *pix = (pixel*)_pix;
 +    pixel *pix = (pixel*)p_pix;
      int d;
 -    xstride /= sizeof(pixel);
 -    ystride /= sizeof(pixel);
 +    xstride >>= sizeof(pixel)-1;
 +    ystride >>= sizeof(pixel)-1;
      alpha <<= BIT_DEPTH - 8;
      beta  <<= BIT_DEPTH - 8;
      for( d = 0; d < 4 * inner_iters; d++ ) {
@@@ -2,20 -2,20 +2,20 @@@
   * H.264 IDCT
   * Copyright (c) 2004-2011 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
   */
  
@@@ -52,7 -52,7 +52,7 @@@ void FUNCC(ff_h264_idct_add)(uint8_t *_
      INIT_CLIP
      pixel *dst = (pixel*)_dst;
      dctcoef *block = (dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      block[0] += 1 << 5;
  
@@@ -86,7 -86,7 +86,7 @@@ void FUNCC(ff_h264_idct8_add)(uint8_t *
      INIT_CLIP
      pixel *dst = (pixel*)_dst;
      dctcoef *block = (dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      block[0] += 32;
  
  }
  
  // assumes all AC coefs are 0
 -void FUNCC(ff_h264_idct_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
 +void FUNCC(ff_h264_idct_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
      int i, j;
      int dc = (((dctcoef*)block)[0] + 32) >> 6;
      INIT_CLIP
 -    pixel *dst = (pixel*)_dst;
 -    stride /= sizeof(pixel);
 +    pixel *dst = (pixel*)p_dst;
 +    stride >>= sizeof(pixel)-1;
      for( j = 0; j < 4; j++ )
      {
          for( i = 0; i < 4; i++ )
      }
  }
  
 -void FUNCC(ff_h264_idct8_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
 +void FUNCC(ff_h264_idct8_dc_add)(uint8_t *p_dst, DCTELEM *block, int stride){
      int i, j;
      int dc = (((dctcoef*)block)[0] + 32) >> 6;
      INIT_CLIP
 -    pixel *dst = (pixel*)_dst;
 -    stride /= sizeof(pixel);
 +    pixel *dst = (pixel*)p_dst;
 +    stride >>= sizeof(pixel)-1;
      for( j = 0; j < 8; j++ )
      {
          for( i = 0; i < 8; i++ )
@@@ -228,16 -228,6 +228,6 @@@ void FUNCC(ff_h264_idct_add8)(uint8_t *
  void FUNCC(ff_h264_idct_add8_422)(uint8_t **dest, const int *block_offset, DCTELEM *block, int stride, const uint8_t nnzc[15*8]){
      int i, j;
  
- #if 0
-     av_log(NULL, AV_LOG_INFO, "idct\n");
-     int32_t *b = block;
-     for (int i = 0; i < 256; i++) {
-         av_log(NULL, AV_LOG_INFO, "%5d ", b[i+256]);
-         if (!((i+1) % 16))
-             av_log(NULL, AV_LOG_INFO, "\n");
-     }
- #endif
      for(j=1; j<3; j++){
          for(i=j*16; i<j*16+4; i++){
              if(nnzc[ scan8[i] ])
   * IDCT transforms the 16 dc values and dequantizes them.
   * @param qmul quantization parameter
   */
 -void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *_output, DCTELEM *_input, int qmul){
 +void FUNCC(ff_h264_luma_dc_dequant_idct)(DCTELEM *p_output, DCTELEM *p_input, int qmul){
  #define stride 16
      int i;
      int temp[16];
      static const uint8_t x_offset[4]={0, 2*stride, 8*stride, 10*stride};
 -    dctcoef *input = (dctcoef*)_input;
 -    dctcoef *output = (dctcoef*)_output;
 +    dctcoef *input = (dctcoef*)p_input;
 +    dctcoef *output = (dctcoef*)p_output;
  
      for(i=0; i<4; i++){
          const int z0= input[4*i+0] + input[4*i+1];
  #undef stride
  }
  
- void FUNCC(ff_h264_chroma422_dc_dequant_idct)(DCTELEM *p_block, int qmul){
+ void FUNCC(ff_h264_chroma422_dc_dequant_idct)(DCTELEM *_block, int qmul){
      const int stride= 16*2;
      const int xStride= 16;
      int i;
      int temp[8];
      static const uint8_t x_offset[2]={0, 16};
-     dctcoef *block = (dctcoef*)p_block;
+     dctcoef *block = (dctcoef*)_block;
  
      for(i=0; i<4; i++){
          temp[2*i+0] = block[stride*i + xStride*0] + block[stride*i + xStride*1];
          block[stride*2+offset]= ((z1 - z2)*qmul + 128) >> 8;
          block[stride*3+offset]= ((z0 - z3)*qmul + 128) >> 8;
      }
- #if 0
-     av_log(NULL, AV_LOG_INFO, "after chroma dc\n");
-     for (int i = 0; i < 256; i++) {
-         av_log(NULL, AV_LOG_INFO, "%5d ", block[i]);
-         if (!((i+1) % 16))
-             av_log(NULL, AV_LOG_INFO, "\n");
-     }
- #endif
  }
  
- void FUNCC(ff_h264_chroma_dc_dequant_idct)(DCTELEM *p_block, int qmul){
+ void FUNCC(ff_h264_chroma_dc_dequant_idct)(DCTELEM *_block, int qmul){
      const int stride= 16*2;
      const int xStride= 16;
      int a,b,c,d,e;
-     dctcoef *block = (dctcoef*)p_block;
+     dctcoef *block = (dctcoef*)_block;
  
      a= block[stride*0 + xStride*0];
      b= block[stride*0 + xStride*1];
diff --combined libavcodec/h264pred.c
@@@ -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
   */
  
@@@ -462,10 -462,10 +462,10 @@@ void ff_h264_pred_init(H264PredContext 
              h->pred8x8[DC_PRED8x8     ]= FUNCC(pred8x16_dc                    , depth);\
              h->pred8x8[LEFT_DC_PRED8x8]= FUNCC(pred8x16_left_dc               , depth);\
              h->pred8x8[TOP_DC_PRED8x8 ]= FUNCC(pred8x16_top_dc                , depth);\
-             h->pred8x8[ALZHEIMER_DC_L0T_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_l0t, depth);\
-             h->pred8x8[ALZHEIMER_DC_0LT_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_0lt, depth);\
-             h->pred8x8[ALZHEIMER_DC_L00_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_l00, depth);\
-             h->pred8x8[ALZHEIMER_DC_0L0_PRED8x8 ]= FUNC(pred8x8_mad_cow_dc_0l0, depth);\
+             h->pred8x8[ALZHEIMER_DC_L0T_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_l0t, depth);\
+             h->pred8x8[ALZHEIMER_DC_0LT_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_0lt, depth);\
+             h->pred8x8[ALZHEIMER_DC_L00_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_l00, depth);\
+             h->pred8x8[ALZHEIMER_DC_0L0_PRED8x8 ]= FUNC(pred8x16_mad_cow_dc_0l0, depth);\
          }\
      }else{\
          h->pred8x8[DC_PRED8x8     ]= FUNCD(pred8x8_dc_rv40);\
      h->pred4x4_add  [ HOR_PRED   ]= FUNCC(pred4x4_horizontal_add          , depth);\
      h->pred8x8l_add [VERT_PRED   ]= FUNCC(pred8x8l_vertical_add           , depth);\
      h->pred8x8l_add [ HOR_PRED   ]= FUNCC(pred8x8l_horizontal_add         , depth);\
+     if (chroma_format_idc == 1) {\
      h->pred8x8_add  [VERT_PRED8x8]= FUNCC(pred8x8_vertical_add            , depth);\
      h->pred8x8_add  [ HOR_PRED8x8]= FUNCC(pred8x8_horizontal_add          , depth);\
+     } else {\
+         h->pred8x8_add  [VERT_PRED8x8]= FUNCC(pred8x16_vertical_add            , depth);\
+         h->pred8x8_add  [ HOR_PRED8x8]= FUNCC(pred8x16_horizontal_add          , depth);\
+     }\
      h->pred16x16_add[VERT_PRED8x8]= FUNCC(pred16x16_vertical_add          , depth);\
      h->pred16x16_add[ HOR_PRED8x8]= FUNCC(pred16x16_horizontal_add        , depth);\
  
@@@ -2,20 -2,20 +2,20 @@@
   * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
   * Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -31,7 -31,7 +31,7 @@@
  
  static void FUNCC(pred4x4_vertical)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a= AV_RN4PA(src-stride);
  
      AV_WN4PA(src+0*stride, a);
@@@ -42,7 -42,7 +42,7 @@@
  
  static void FUNCC(pred4x4_horizontal)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      AV_WN4PA(src+0*stride, PIXEL_SPLAT_X4(src[-1+0*stride]));
      AV_WN4PA(src+1*stride, PIXEL_SPLAT_X4(src[-1+1*stride]));
      AV_WN4PA(src+2*stride, PIXEL_SPLAT_X4(src[-1+2*stride]));
@@@ -51,7 -51,7 +51,7 @@@
  
  static void FUNCC(pred4x4_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
                     + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
      const pixel4 a = PIXEL_SPLAT_X4(dc);
@@@ -64,7 -64,7 +64,7 @@@
  
  static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
      const pixel4 a = PIXEL_SPLAT_X4(dc);
  
@@@ -76,7 -76,7 +76,7 @@@
  
  static void FUNCC(pred4x4_top_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
      const pixel4 a = PIXEL_SPLAT_X4(dc);
  
@@@ -88,7 -88,7 +88,7 @@@
  
  static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a = PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1));
  
      AV_WN4PA(src+0*stride, a);
@@@ -99,7 -99,7 +99,7 @@@
  
  static void FUNCC(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))-1);
  
      AV_WN4PA(src+0*stride, a);
  
  static void FUNCC(pred4x4_129_dc)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))+1);
  
      AV_WN4PA(src+0*stride, a);
  
  static void FUNCC(pred4x4_down_right)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int lt= src[-1-1*stride];
      LOAD_TOP_EDGE
      LOAD_LEFT_EDGE
  static void FUNCC(pred4x4_down_left)(uint8_t *_src, const uint8_t *_topright, int _stride){
      pixel *src = (pixel*)_src;
      const pixel *topright = (const pixel*)_topright;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      LOAD_TOP_EDGE
      LOAD_TOP_RIGHT_EDGE
  //    LOAD_LEFT_EDGE
  
  static void FUNCC(pred4x4_vertical_right)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int lt= src[-1-1*stride];
      LOAD_TOP_EDGE
      LOAD_LEFT_EDGE
  static void FUNCC(pred4x4_vertical_left)(uint8_t *_src, const uint8_t *_topright, int _stride){
      pixel *src = (pixel*)_src;
      const pixel *topright = (const pixel*)_topright;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      LOAD_TOP_EDGE
      LOAD_TOP_RIGHT_EDGE
  
  
  static void FUNCC(pred4x4_horizontal_up)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      LOAD_LEFT_EDGE
  
      src[0+0*stride]=(l0 + l1 + 1)>>1;
  
  static void FUNCC(pred4x4_horizontal_down)(uint8_t *_src, const uint8_t *topright, int _stride){
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const int lt= src[-1-1*stride];
      LOAD_TOP_EDGE
      LOAD_LEFT_EDGE
  static void FUNCC(pred16x16_vertical)(uint8_t *_src, int _stride){
      int i;
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a = AV_RN4PA(((pixel4*)(src-stride))+0);
      const pixel4 b = AV_RN4PA(((pixel4*)(src-stride))+1);
      const pixel4 c = AV_RN4PA(((pixel4*)(src-stride))+2);
  static void FUNCC(pred16x16_horizontal)(uint8_t *_src, int stride){
      int i;
      pixel *src = (pixel*)_src;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      for(i=0; i<16; i++){
          const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
@@@ -338,7 -338,7 +338,7 @@@ static void FUNCC(pred16x16_dc)(uint8_
      int i, dc=0;
      pixel *src = (pixel*)_src;
      pixel4 dcsplat;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      for(i=0;i<16; i++){
          dc+= src[-1+i*stride];
@@@ -356,7 -356,7 +356,7 @@@ static void FUNCC(pred16x16_left_dc)(ui
      int i, dc=0;
      pixel *src = (pixel*)_src;
      pixel4 dcsplat;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      for(i=0;i<16; i++){
          dc+= src[-1+i*stride];
@@@ -370,7 -370,7 +370,7 @@@ static void FUNCC(pred16x16_top_dc)(uin
      int i, dc=0;
      pixel *src = (pixel*)_src;
      pixel4 dcsplat;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      for(i=0;i<16; i++){
          dc+= src[i-stride];
  static void FUNCC(pred16x16_##n##_dc)(uint8_t *_src, int stride){\
      int i;\
      pixel *src = (pixel*)_src;\
 -    stride /= sizeof(pixel);\
 +    stride >>= sizeof(pixel)-1;\
      PREDICT_16x16_DC(PIXEL_SPLAT_X4(v));\
  }
  
@@@ -392,12 -392,12 +392,12 @@@ PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1)
  PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0);
  PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1);
  
 -static inline void FUNCC(pred16x16_plane_compat)(uint8_t *_src, int _stride, const int svq3, const int rv40){
 +static inline void FUNCC(pred16x16_plane_compat)(uint8_t *p_src, int p_stride, const int svq3, const int rv40){
    int i, j, k;
    int a;
    INIT_CLIP
 -  pixel *src = (pixel*)_src;
 -  int stride = _stride/sizeof(pixel);
 +  pixel *src = (pixel*)p_src;
 +  int stride = p_stride>>(sizeof(pixel)-1);
    const pixel * const src0 = src +7-stride;
    const pixel *       src1 = src +8*stride-1;
    const pixel *       src2 = src1-2*stride;    // == src+6*stride-1;
@@@ -444,7 -444,7 +444,7 @@@ static void FUNCC(pred16x16_plane)(uint
  static void FUNCC(pred8x8_vertical)(uint8_t *_src, int _stride){
      int i;
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
      const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
  
@@@ -470,7 -470,7 +470,7 @@@ static void FUNCC(pred8x16_vertical)(ui
  static void FUNCC(pred8x8_horizontal)(uint8_t *_src, int stride){
      int i;
      pixel *src = (pixel*)_src;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      for(i=0; i<8; i++){
          const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
@@@ -495,7 -495,7 +495,7 @@@ static void FUNCC(pred8x8_##n##_dc)(uin
      int i;\
      const pixel4 a = PIXEL_SPLAT_X4(v);\
      pixel *src = (pixel*)_src;\
 -    stride /= sizeof(pixel);\
 +    stride >>= sizeof(pixel)-1;\
      for(i=0; i<8; i++){\
          AV_WN4PA(((pixel4*)(src+i*stride))+0, a);\
          AV_WN4PA(((pixel4*)(src+i*stride))+1, a);\
@@@ -516,7 -516,7 +516,7 @@@ static void FUNCC(pred8x8_left_dc)(uint
      int dc0, dc2;
      pixel4 dc0splat, dc2splat;
      pixel *src = (pixel*)_src;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      dc0=dc2=0;
      for(i=0;i<4; i++){
@@@ -546,7 -546,7 +546,7 @@@ static void FUNCC(pred8x8_top_dc)(uint8
      int dc0, dc1;
      pixel4 dc0splat, dc1splat;
      pixel *src = (pixel*)_src;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      dc0=dc1=0;
      for(i=0;i<4; i++){
@@@ -592,7 -592,7 +592,7 @@@ static void FUNCC(pred8x8_dc)(uint8_t *
      int dc0, dc1, dc2;
      pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
      pixel *src = (pixel*)_src;
 -    stride /= sizeof(pixel);
 +    stride >>= sizeof(pixel)-1;
  
      dc0=dc1=dc2=0;
      for(i=0;i<4; i++){
@@@ -657,35 -657,56 +657,57 @@@ static void FUNCC(pred8x16_dc)(uint8_t 
      }
  }
  
 +//the following 4 function should not be optimized!
  static void FUNC(pred8x8_mad_cow_dc_l0t)(uint8_t *src, int stride){
      FUNCC(pred8x8_top_dc)(src, stride);
      FUNCC(pred4x4_dc)(src, NULL, stride);
  }
  
+ static void FUNC(pred8x16_mad_cow_dc_l0t)(uint8_t *src, int stride){
+     FUNCC(pred8x16_top_dc)(src, stride);
+     FUNCC(pred4x4_dc)(src, NULL, stride);
+ }
  static void FUNC(pred8x8_mad_cow_dc_0lt)(uint8_t *src, int stride){
      FUNCC(pred8x8_dc)(src, stride);
      FUNCC(pred4x4_top_dc)(src, NULL, stride);
  }
  
+ static void FUNC(pred8x16_mad_cow_dc_0lt)(uint8_t *src, int stride){
+     FUNCC(pred8x16_dc)(src, stride);
+     FUNCC(pred4x4_top_dc)(src, NULL, stride);
+ }
  static void FUNC(pred8x8_mad_cow_dc_l00)(uint8_t *src, int stride){
      FUNCC(pred8x8_left_dc)(src, stride);
      FUNCC(pred4x4_128_dc)(src + 4*stride                  , NULL, stride);
      FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
  }
  
+ static void FUNC(pred8x16_mad_cow_dc_l00)(uint8_t *src, int stride){
+     FUNCC(pred8x16_left_dc)(src, stride);
+     FUNCC(pred4x4_128_dc)(src + 4*stride                  , NULL, stride);
+     FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
+ }
  static void FUNC(pred8x8_mad_cow_dc_0l0)(uint8_t *src, int stride){
      FUNCC(pred8x8_left_dc)(src, stride);
      FUNCC(pred4x4_128_dc)(src                  , NULL, stride);
      FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
  }
  
+ static void FUNC(pred8x16_mad_cow_dc_0l0)(uint8_t *src, int stride){
+     FUNCC(pred8x16_left_dc)(src, stride);
+     FUNCC(pred4x4_128_dc)(src                  , NULL, stride);
+     FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
+ }
  static void FUNCC(pred8x8_plane)(uint8_t *_src, int _stride){
    int j, k;
    int a;
    INIT_CLIP
    pixel *src = (pixel*)_src;
 -  int stride = _stride/sizeof(pixel);
 +  int stride = _stride>>(sizeof(pixel)-1);
    const pixel * const src0 = src +3-stride;
    const pixel *       src1 = src +4*stride-1;
    const pixel *       src2 = src1-2*stride;    // == src+2*stride-1;
@@@ -797,32 -818,32 +819,32 @@@ static void FUNCC(pred8x16_plane)(uint8
  static void FUNCC(pred8x8l_128_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
  {
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
  
      PREDICT_8x8_DC(PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1)));
  }
  static void FUNCC(pred8x8l_left_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
  {
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
  
      PREDICT_8x8_LOAD_LEFT;
      const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3);
      PREDICT_8x8_DC(dc);
  }
 -static void FUNCC(pred8x8l_top_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_top_dc)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
  
      PREDICT_8x8_LOAD_TOP;
      const pixel4 dc = PIXEL_SPLAT_X4((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3);
      PREDICT_8x8_DC(dc);
  }
 -static void FUNCC(pred8x8l_dc)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_dc)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
  
      PREDICT_8x8_LOAD_LEFT;
      PREDICT_8x8_LOAD_TOP;
                                       +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4);
      PREDICT_8x8_DC(dc);
  }
 -static void FUNCC(pred8x8l_horizontal)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_horizontal)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      pixel4 a;
  
      PREDICT_8x8_LOAD_LEFT;
@@@ -847,7 -868,7 +869,7 @@@ static void FUNCC(pred8x8l_vertical)(ui
  {
      int y;
      pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    int stride = _stride>>(sizeof(pixel)-1);
      pixel4 a, b;
  
      PREDICT_8x8_LOAD_TOP;
          AV_WN4PA(((pixel4*)(src+y*stride))+1, b);
      }
  }
 -static void FUNCC(pred8x8l_down_left)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_down_left)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_TOP;
      PREDICT_8x8_LOAD_TOPRIGHT;
      SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
      SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
      SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
  }
 -static void FUNCC(pred8x8l_down_right)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_down_right)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_TOP;
      PREDICT_8x8_LOAD_LEFT;
      PREDICT_8x8_LOAD_TOPLEFT;
      SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
      SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
  }
 -static void FUNCC(pred8x8l_vertical_right)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_vertical_right)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_TOP;
      PREDICT_8x8_LOAD_LEFT;
      PREDICT_8x8_LOAD_TOPLEFT;
      SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
      SRC(7,0)= (t6 + t7 + 1) >> 1;
  }
 -static void FUNCC(pred8x8l_horizontal_down)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_horizontal_down)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_TOP;
      PREDICT_8x8_LOAD_LEFT;
      PREDICT_8x8_LOAD_TOPLEFT;
      SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
      SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
  }
 -static void FUNCC(pred8x8l_vertical_left)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_vertical_left)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_TOP;
      PREDICT_8x8_LOAD_TOPRIGHT;
      SRC(0,0)= (t0 + t1 + 1) >> 1;
      SRC(7,6)= (t10 + t11 + 1) >> 1;
      SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
  }
 -static void FUNCC(pred8x8l_horizontal_up)(uint8_t *_src, int has_topleft, int has_topright, int _stride)
 +static void FUNCC(pred8x8l_horizontal_up)(uint8_t *p_src, int has_topleft, int has_topright, int p_stride)
  {
 -    pixel *src = (pixel*)_src;
 -    int stride = _stride/sizeof(pixel);
 +    pixel *src = (pixel*)p_src;
 +    int stride = p_stride>>(sizeof(pixel)-1);
      PREDICT_8x8_LOAD_LEFT;
      SRC(0,0)= (l0 + l1 + 1) >> 1;
      SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
  #undef PL
  #undef SRC
  
 -static void FUNCC(pred4x4_vertical_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
 +static void FUNCC(pred4x4_vertical_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
      int i;
 -    pixel *pix = (pixel*)_pix;
 -    const dctcoef *block = (const dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    pixel *pix = (pixel*)p_pix;
 +    const dctcoef *block = (const dctcoef*)p_block;
 +    stride >>= sizeof(pixel)-1;
      pix -= stride;
      for(i=0; i<4; i++){
          pixel v = pix[0];
      }
  }
  
 -static void FUNCC(pred4x4_horizontal_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
 +static void FUNCC(pred4x4_horizontal_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
      int i;
 -    pixel *pix = (pixel*)_pix;
 -    const dctcoef *block = (const dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    pixel *pix = (pixel*)p_pix;
 +    const dctcoef *block = (const dctcoef*)p_block;
 +    stride >>= sizeof(pixel)-1;
      for(i=0; i<4; i++){
          pixel v = pix[-1];
          pix[0]= v += block[0];
      }
  }
  
 -static void FUNCC(pred8x8l_vertical_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
 +static void FUNCC(pred8x8l_vertical_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
      int i;
 -    pixel *pix = (pixel*)_pix;
 -    const dctcoef *block = (const dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    pixel *pix = (pixel*)p_pix;
 +    const dctcoef *block = (const dctcoef*)p_block;
 +    stride >>= sizeof(pixel)-1;
      pix -= stride;
      for(i=0; i<8; i++){
          pixel v = pix[0];
      }
  }
  
 -static void FUNCC(pred8x8l_horizontal_add)(uint8_t *_pix, const DCTELEM *_block, int stride){
 +static void FUNCC(pred8x8l_horizontal_add)(uint8_t *p_pix, const DCTELEM *p_block, int stride){
      int i;
 -    pixel *pix = (pixel*)_pix;
 -    const dctcoef *block = (const dctcoef*)_block;
 -    stride /= sizeof(pixel);
 +    pixel *pix = (pixel*)p_pix;
 +    const dctcoef *block = (const dctcoef*)p_block;
 +    stride >>= sizeof(pixel)-1;
      for(i=0; i<8; i++){
          pixel v = pix[-1];
          pix[0]= v += block[0];
@@@ -1126,8 -1147,24 +1148,24 @@@ static void FUNCC(pred8x8_vertical_add)
          FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
  }
  
+ static void FUNCC(pred8x16_vertical_add)(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){
+     int i;
+     for(i=0; i<4; i++)
+         FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
+     for(i=4; i<8; i++)
+         FUNCC(pred4x4_vertical_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
+ }
  static void FUNCC(pred8x8_horizontal_add)(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){
      int i;
      for(i=0; i<4; i++)
          FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
  }
+ static void FUNCC(pred8x16_horizontal_add)(uint8_t *pix, const int *block_offset, const DCTELEM *block, int stride){
+     int i;
+     for(i=0; i<4; i++)
+         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
+     for(i=4; i<8; i++)
+         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
+ }
diff --combined libavcodec/libspeexdec.c
@@@ -1,28 -1,28 +1,28 @@@
  /*
   * Copyright (C) 2008 David Conrad
   *
 - * 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 "avcodec.h"
  #include <speex/speex.h>
  #include <speex/speex_header.h>
  #include <speex/speex_stereo.h>
  #include <speex/speex_callbacks.h>
+ #include "avcodec.h"
  
  typedef struct {
      SpeexBits bits;
@@@ -60,14 -60,14 +60,14 @@@ static av_cold int libspeex_decode_init
          mode = speex_lib_get_mode(s->header->mode);
          if (!mode) {
              av_log(avctx, AV_LOG_ERROR, "Unknown Speex mode %d", s->header->mode);
-             return -1;
+             return AVERROR_INVALIDDATA;
          }
      } else
          av_log(avctx, AV_LOG_INFO, "Missing Speex header, assuming defaults.\n");
  
      if (avctx->channels > 2) {
          av_log(avctx, AV_LOG_ERROR, "Only stereo and mono are supported.\n");
-         return -1;
+         return AVERROR(EINVAL);
      }
  
      speex_bits_init(&s->bits);
@@@ -99,32 -99,42 +99,42 @@@ static int libspeex_decode_frame(AVCode
      uint8_t *buf = avpkt->data;
      int buf_size = avpkt->size;
      LibSpeexContext *s = avctx->priv_data;
-     int16_t *output = data, *end;
-     int i, num_samples;
-     num_samples = s->frame_size * avctx->channels;
-     end = output + *data_size / sizeof(*output);
-     speex_bits_read_from(&s->bits, buf, buf_size);
-     for (i = 0; speex_bits_remaining(&s->bits) && output + num_samples < end; i++) {
-         int ret = speex_decode_int(s->dec_state, &s->bits, output);
-         if (ret <= -2) {
-             av_log(avctx, AV_LOG_ERROR, "Error decoding Speex frame.\n");
-             return -1;
-         } else if (ret == -1)
-             // end of stream
-             break;
+     int16_t *output = data;
+     int out_size, ret, consumed = 0;
+     /* check output buffer size */
+     out_size = s->frame_size * avctx->channels *
+                av_get_bytes_per_sample(avctx->sample_fmt);
+     if (*data_size < out_size) {
+         av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");
+         return AVERROR(EINVAL);
+     }
  
-         if (avctx->channels == 2)
-             speex_decode_stereo_int(output, s->frame_size, &s->stereo);
+     /* if there is not enough data left for the smallest possible frame,
+        reset the libspeex buffer using the current packet, otherwise ignore
+        the current packet and keep decoding frames from the libspeex buffer. */
+     if (speex_bits_remaining(&s->bits) < 43) {
+         /* check for flush packet */
+         if (!buf || !buf_size) {
+             *data_size = 0;
+             return buf_size;
+         }
+         /* set new buffer */
+         speex_bits_read_from(&s->bits, buf, buf_size);
+         consumed = buf_size;
+     }
  
-         output += num_samples;
+     /* decode a single frame */
+     ret = speex_decode_int(s->dec_state, &s->bits, output);
+     if (ret <= -2) {
+         av_log(avctx, AV_LOG_ERROR, "Error decoding Speex frame.\n");
+         return AVERROR_INVALIDDATA;
      }
+     if (avctx->channels == 2)
+         speex_decode_stereo_int(output, s->frame_size, &s->stereo);
  
-     avctx->frame_size = s->frame_size * i;
-     *data_size = avctx->channels * avctx->frame_size * sizeof(*output);
-     return buf_size;
+     *data_size = out_size;
+     return consumed;
  }
  
  static av_cold int libspeex_decode_close(AVCodecContext *avctx)
      return 0;
  }
  
+ static av_cold void libspeex_decode_flush(AVCodecContext *avctx)
+ {
+     LibSpeexContext *s = avctx->priv_data;
+     speex_bits_reset(&s->bits);
+ }
  AVCodec ff_libspeex_decoder = {
      .name           = "libspeex",
      .type           = AVMEDIA_TYPE_AUDIO,
      .init           = libspeex_decode_init,
      .close          = libspeex_decode_close,
      .decode         = libspeex_decode_frame,
+     .flush          = libspeex_decode_flush,
+     .capabilities   = CODEC_CAP_SUBFRAMES | CODEC_CAP_DELAY,
      .long_name = NULL_IF_CONFIG_SMALL("libspeex Speex"),
  };
@@@ -2,20 -2,20 +2,20 @@@
   * MPEG Audio decoder
   * Copyright (c) 2001, 2002 Fabrice Bellard
   *
 - * 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
   */
  
@@@ -1709,6 -1709,7 +1709,6 @@@ static int mp_decode_frame(MPADecodeCon
      if (s->error_protection)
          skip_bits(&s->gb, 16);
  
 -    av_dlog(s->avctx, "frame %d:\n", s->frame_count);
      switch(s->layer) {
      case 1:
          s->avctx->frame_size = 384;
@@@ -1809,7 -1810,7 +1809,7 @@@ static int decode_frame(AVCodecContext 
          av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
          return -1;
      }else if(s->frame_size < buf_size){
 -        av_log(avctx, AV_LOG_ERROR, "incorrect frame size\n");
 +        av_log(avctx, AV_LOG_DEBUG, "incorrect frame size - multiple frames in buffer?\n");
          buf_size= s->frame_size;
      }
  
@@@ -1893,24 -1894,50 +1893,50 @@@ typedef struct MP3On4DecodeContext 
      int syncword; ///< syncword patch
      const uint8_t *coff; ///< channels offsets in output buffer
      MPADecodeContext *mp3decctx[5]; ///< MPADecodeContext for every decoder instance
+     OUT_INT *decoded_buf;           ///< output buffer for decoded samples
  } MP3On4DecodeContext;
  
  #include "mpeg4audio.h"
  
  /* Next 3 arrays are indexed by channel config number (passed via codecdata) */
  static const uint8_t mp3Frames[8] = {0,1,1,2,3,3,4,5};   /* number of mp3 decoder instances */
- /* offsets into output buffer, assume output order is FL FR BL BR C LFE */
+ /* offsets into output buffer, assume output order is FL FR C LFE BL BR SL SR */
  static const uint8_t chan_offset[8][5] = {
      {0},
      {0},            // C
      {0},            // FLR
      {2,0},          // C FLR
      {2,0,3},        // C FLR BS
-     {4,0,2},        // C FLR BLRS
-     {4,0,2,5},      // C FLR BLRS LFE
-     {4,0,2,6,5},    // C FLR BLRS BLR LFE
+     {2,0,3},        // C FLR BLRS
+     {2,0,4,3},      // C FLR BLRS LFE
+     {2,0,6,4,3},    // C FLR BLRS BLR LFE
  };
  
+ /* mp3on4 channel layouts */
+ static const int16_t chan_layout[8] = {
+     0,
+     AV_CH_LAYOUT_MONO,
+     AV_CH_LAYOUT_STEREO,
+     AV_CH_LAYOUT_SURROUND,
+     AV_CH_LAYOUT_4POINT0,
+     AV_CH_LAYOUT_5POINT0,
+     AV_CH_LAYOUT_5POINT1,
+     AV_CH_LAYOUT_7POINT1
+ };
+ static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
+ {
+     MP3On4DecodeContext *s = avctx->priv_data;
+     int i;
+     for (i = 0; i < s->frames; i++)
+         av_free(s->mp3decctx[i]);
+     av_freep(&s->decoded_buf);
+     return 0;
+ }
  
  static int decode_init_mp3on4(AVCodecContext * avctx)
  {
      s->frames = mp3Frames[cfg.chan_config];
      s->coff = chan_offset[cfg.chan_config];
      avctx->channels = ff_mpeg4audio_channels[cfg.chan_config];
+     avctx->channel_layout = chan_layout[cfg.chan_config];
  
      if (cfg.sample_rate < 16000)
          s->syncword = 0xffe00000;
       */
      // Allocate zeroed memory for the first decoder context
      s->mp3decctx[0] = av_mallocz(sizeof(MPADecodeContext));
+     if (!s->mp3decctx[0])
+         goto alloc_fail;
      // Put decoder context in place to make init_decode() happy
      avctx->priv_data = s->mp3decctx[0];
      decode_init(avctx);
       */
      for (i = 1; i < s->frames; i++) {
          s->mp3decctx[i] = av_mallocz(sizeof(MPADecodeContext));
+         if (!s->mp3decctx[i])
+             goto alloc_fail;
          s->mp3decctx[i]->adu_mode = 1;
          s->mp3decctx[i]->avctx = avctx;
+         s->mp3decctx[i]->mpadsp = s->mp3decctx[0]->mpadsp;
+     }
+     /* Allocate buffer for multi-channel output if needed */
+     if (s->frames > 1) {
+         s->decoded_buf = av_malloc(MPA_FRAME_SIZE * MPA_MAX_CHANNELS *
+                                    sizeof(*s->decoded_buf));
+         if (!s->decoded_buf)
+             goto alloc_fail;
      }
  
      return 0;
+ alloc_fail:
+     decode_close_mp3on4(avctx);
+     return AVERROR(ENOMEM);
  }
  
  
- static av_cold int decode_close_mp3on4(AVCodecContext * avctx)
+ static void flush_mp3on4(AVCodecContext *avctx)
  {
-     MP3On4DecodeContext *s = avctx->priv_data;
      int i;
+     MP3On4DecodeContext *s = avctx->priv_data;
  
-     for (i = 0; i < s->frames; i++)
-         av_free(s->mp3decctx[i]);
-     return 0;
+     for (i = 0; i < s->frames; i++) {
+         MPADecodeContext *m = s->mp3decctx[i];
+         memset(m->synth_buf, 0, sizeof(m->synth_buf));
+         m->last_buf_size = 0;
+     }
  }
  
  
@@@ -1987,12 -2032,13 +2031,13 @@@ static int decode_frame_mp3on4(AVCodecC
      int fsize, len = buf_size, out_size = 0;
      uint32_t header;
      OUT_INT *out_samples = data;
-     OUT_INT decoded_buf[MPA_FRAME_SIZE * MPA_MAX_CHANNELS];
      OUT_INT *outptr, *bp;
-     int fr, j, n;
+     int fr, j, n, ch;
  
-     if(*data_size < MPA_FRAME_SIZE * MPA_MAX_CHANNELS * s->frames * sizeof(OUT_INT))
-         return -1;
+     if (*data_size < MPA_FRAME_SIZE * avctx->channels * sizeof(OUT_INT)) {
+         av_log(avctx, AV_LOG_ERROR, "output buffer is too small\n");
+         return AVERROR(EINVAL);
+     }
  
      *data_size = 0;
      // Discard too short frames
          return -1;
  
      // If only one decoder interleave is not needed
-     outptr = s->frames == 1 ? out_samples : decoded_buf;
+     outptr = s->frames == 1 ? out_samples : s->decoded_buf;
  
      avctx->bit_rate = 0;
  
+     ch = 0;
      for (fr = 0; fr < s->frames; fr++) {
          fsize = AV_RB16(buf) >> 4;
          fsize = FFMIN3(fsize, len, MPA_MAX_CODED_FRAME_SIZE);
              break;
  
          avpriv_mpegaudio_decode_header((MPADecodeHeader *)m, header);
+         if (ch + m->nb_channels > avctx->channels) {
+             av_log(avctx, AV_LOG_ERROR, "frame channel count exceeds codec "
+                                         "channel count\n");
+             return AVERROR_INVALIDDATA;
+         }
+         ch += m->nb_channels;
          out_size += mp_decode_frame(m, outptr, buf, fsize);
          buf += fsize;
          len -= fsize;
              bp = out_samples + s->coff[fr];
              if(m->nb_channels == 1) {
                  for(j = 0; j < n; j++) {
-                     *bp = decoded_buf[j];
+                     *bp = s->decoded_buf[j];
                      bp += avctx->channels;
                  }
              } else {
                  for(j = 0; j < n; j++) {
-                     bp[0] = decoded_buf[j++];
-                     bp[1] = decoded_buf[j];
+                     bp[0] = s->decoded_buf[j++];
+                     bp[1] = s->decoded_buf[j];
                      bp += avctx->channels;
                  }
              }
@@@ -2110,7 -2165,7 +2164,7 @@@ AVCodec ff_mp3on4_decoder = 
      .init           = decode_init_mp3on4,
      .close          = decode_close_mp3on4,
      .decode         = decode_frame_mp3on4,
-     .flush          = flush,
+     .flush          = flush_mp3on4,
      .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
  };
  #endif
@@@ -2,20 -2,20 +2,20 @@@
   * Float MPEG Audio decoder
   * Copyright (c) 2010 Michael Niedermayer
   *
 - * 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
   */
  
@@@ -83,7 -83,7 +83,7 @@@ AVCodec ff_mp3on4float_decoder = 
      .init           = decode_init_mp3on4,
      .close          = decode_close_mp3on4,
      .decode         = decode_frame_mp3on4,
-     .flush          = flush,
+     .flush          = flush_mp3on4,
      .long_name      = NULL_IF_CONFIG_SMALL("MP3onMP4"),
  };
  #endif
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
   *
 - * 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
   */
  
@@@ -843,7 -843,8 +843,8 @@@ static void h264_h_loop_filter_luma_alt
  }
  
  static av_always_inline
- void weight_h264_WxH_altivec(uint8_t *block, int stride, int log2_denom, int weight, int offset, int w, int h)
+ void weight_h264_W_altivec(uint8_t *block, int stride, int height,
+                            int log2_denom, int weight, int offset, int w)
  {
      int y, aligned;
      vec_u8 vblock;
      voffset = vec_splat(vtemp, 5);
      aligned = !((unsigned long)block & 0xf);
  
-     for (y=0; y<h; y++) {
+     for (y = 0; y < height; y++) {
          vblock = vec_ld(0, block);
  
          v0 = (vec_s16)vec_mergeh(zero_u8v, vblock);
  }
  
  static av_always_inline
- void biweight_h264_WxH_altivec(uint8_t *dst, uint8_t *src, int stride, int log2_denom,
-                                int weightd, int weights, int offset, int w, int h)
+ void biweight_h264_W_altivec(uint8_t *dst, uint8_t *src, int stride, int height,
+                              int log2_denom, int weightd, int weights, int offset, int w)
  {
      int y, dst_aligned, src_aligned;
      vec_u8 vsrc, vdst;
      dst_aligned = !((unsigned long)dst & 0xf);
      src_aligned = !((unsigned long)src & 0xf);
  
-     for (y=0; y<h; y++) {
+     for (y = 0; y < height; y++) {
          vdst = vec_ld(0, dst);
          vsrc = vec_ld(0, src);
  
      }
  }
  
- #define H264_WEIGHT(W,H) \
- static void ff_weight_h264_pixels ## W ## x ## H ## _altivec(uint8_t *block, int stride, int log2_denom, int weight, int offset){ \
-     weight_h264_WxH_altivec(block, stride, log2_denom, weight, offset, W, H); \
+ #define H264_WEIGHT(W) \
+ static void ff_weight_h264_pixels ## W ## _altivec(uint8_t *block, int stride, int height, \
+                                                    int log2_denom, int weight, int offset){ \
+     weight_h264_W_altivec(block, stride, height, log2_denom, weight, offset, W); \
  }\
- static void ff_biweight_h264_pixels ## W ## x ## H ## _altivec(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ \
-     biweight_h264_WxH_altivec(dst, src, stride, log2_denom, weightd, weights, offset, W, H); \
+ static void ff_biweight_h264_pixels ## W ## _altivec(uint8_t *dst, uint8_t *src, int stride, int height, \
+                                                      int log2_denom, int weightd, int weights, int offset){ \
+     biweight_h264_W_altivec(dst, src, stride, height, log2_denom, weightd, weights, offset, W); \
  }
  
- H264_WEIGHT(16,16)
- H264_WEIGHT(16, 8)
- H264_WEIGHT( 8,16)
- H264_WEIGHT( 8, 8)
- H264_WEIGHT( 8, 4)
+ H264_WEIGHT(16)
+ H264_WEIGHT( 8)
  
  void dsputil_h264_init_ppc(DSPContext* c, AVCodecContext *avctx) {
      const int high_bit_depth = avctx->bits_per_raw_sample > 8;
@@@ -1015,16 -1015,10 +1015,10 @@@ void ff_h264dsp_init_ppc(H264DSPContex
          c->h264_v_loop_filter_luma= h264_v_loop_filter_luma_altivec;
          c->h264_h_loop_filter_luma= h264_h_loop_filter_luma_altivec;
  
-         c->weight_h264_pixels_tab[0] = ff_weight_h264_pixels16x16_altivec;
-         c->weight_h264_pixels_tab[1] = ff_weight_h264_pixels16x8_altivec;
-         c->weight_h264_pixels_tab[2] = ff_weight_h264_pixels8x16_altivec;
-         c->weight_h264_pixels_tab[3] = ff_weight_h264_pixels8x8_altivec;
-         c->weight_h264_pixels_tab[4] = ff_weight_h264_pixels8x4_altivec;
-         c->biweight_h264_pixels_tab[0] = ff_biweight_h264_pixels16x16_altivec;
-         c->biweight_h264_pixels_tab[1] = ff_biweight_h264_pixels16x8_altivec;
-         c->biweight_h264_pixels_tab[2] = ff_biweight_h264_pixels8x16_altivec;
-         c->biweight_h264_pixels_tab[3] = ff_biweight_h264_pixels8x8_altivec;
-         c->biweight_h264_pixels_tab[4] = ff_biweight_h264_pixels8x4_altivec;
+         c->weight_h264_pixels_tab[0] = ff_weight_h264_pixels16_altivec;
+         c->weight_h264_pixels_tab[1] = ff_weight_h264_pixels8_altivec;
+         c->biweight_h264_pixels_tab[0] = ff_biweight_h264_pixels16_altivec;
+         c->biweight_h264_pixels_tab[1] = ff_biweight_h264_pixels8_altivec;
      }
      }
  }
diff --combined libavcodec/utils.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -158,6 -158,8 +158,8 @@@ void avcodec_align_dimensions2(AVCodecC
      case PIX_FMT_YUV420P9BE:
      case PIX_FMT_YUV420P10LE:
      case PIX_FMT_YUV420P10BE:
+     case PIX_FMT_YUV422P9LE:
+     case PIX_FMT_YUV422P9BE:
      case PIX_FMT_YUV422P10LE:
      case PIX_FMT_YUV422P10BE:
      case PIX_FMT_YUV444P9LE:
      case PIX_FMT_YUV444P10BE:
          w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
          h_align= 16;
 -        if(s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id == CODEC_ID_AMV || s->codec_id == CODEC_ID_THP || s->codec_id == CODEC_ID_H264)
 +        if(s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id == CODEC_ID_AMV || s->codec_id == CODEC_ID_THP || s->codec_id == CODEC_ID_H264 || s->codec_id == CODEC_ID_PRORES)
              h_align= 32; // interlaced is rounded up to 2 MBs
          break;
      case PIX_FMT_YUV411P:
@@@ -241,22 -243,6 +243,22 @@@ void avcodec_align_dimensions(AVCodecCo
      *width=FFALIGN(*width, align);
  }
  
 +void ff_init_buffer_info(AVCodecContext *s, AVFrame *pic)
 +{
 +    if (s->pkt) {
 +        pic->pkt_pts = s->pkt->pts;
 +        pic->pkt_pos = s->pkt->pos;
 +    } else {
 +        pic->pkt_pts = AV_NOPTS_VALUE;
 +        pic->pkt_pos = -1;
 +    }
 +    pic->reordered_opaque= s->reordered_opaque;
 +    pic->sample_aspect_ratio = s->sample_aspect_ratio;
 +    pic->width               = s->width;
 +    pic->height              = s->height;
 +    pic->format              = s->pix_fmt;
 +}
 +
  int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
      int i;
      int w= s->width;
      }
      s->internal_buffer_count++;
  
 -    if(s->pkt) pic->pkt_pts= s->pkt->pts;
 -    else       pic->pkt_pts= AV_NOPTS_VALUE;
 +    if (s->pkt) {
 +        pic->pkt_pts = s->pkt->pts;
 +        pic->pkt_pos = s->pkt->pos;
 +    } else {
 +        pic->pkt_pts = AV_NOPTS_VALUE;
 +        pic->pkt_pos = -1;
 +    }
      pic->reordered_opaque= s->reordered_opaque;
 +    pic->sample_aspect_ratio = s->sample_aspect_ratio;
 +    pic->width               = s->width;
 +    pic->height              = s->height;
 +    pic->format              = s->pix_fmt;
  
      if(s->debug&FF_DEBUG_BUFFERS)
          av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
@@@ -496,11 -473,8 +498,11 @@@ enum PixelFormat avcodec_default_get_fo
  void avcodec_get_frame_defaults(AVFrame *pic){
      memset(pic, 0, sizeof(AVFrame));
  
 -    pic->pts= AV_NOPTS_VALUE;
 +    pic->pts = pic->best_effort_timestamp = AV_NOPTS_VALUE;
 +    pic->pkt_pos = -1;
      pic->key_frame= 1;
 +    pic->sample_aspect_ratio = (AVRational){0, 1};
 +    pic->format = -1;           /* unknown */
  }
  
  AVFrame *avcodec_alloc_frame(void){
      return pic;
  }
  
 +static void avcodec_get_subtitle_defaults(AVSubtitle *sub)
 +{
 +    memset(sub, 0, sizeof(*sub));
 +    sub->pts = AV_NOPTS_VALUE;
 +}
 +
  #if FF_API_AVCODEC_OPEN
  int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
  {
@@@ -609,9 -577,6 +611,9 @@@ int attribute_align_arg avcodec_open2(A
      }
      avctx->frame_number = 0;
  
 +    if (!HAVE_THREADS)
 +        av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
 +
      if (HAVE_THREADS && !avctx->thread_opaque) {
          ret = ff_thread_init(avctx);
          if (ret < 0) {
          }
      }
  
 -    if (avctx->codec->max_lowres < avctx->lowres) {
 -        av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
 +    if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
 +        av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
                 avctx->codec->max_lowres);
 -        ret = AVERROR(EINVAL);
 -        goto free_and_end;
 +        avctx->lowres = avctx->codec->max_lowres;
      }
      if (avctx->codec->encode) {
          int i;
          }
      }
  
 +    avctx->pts_correction_num_faulty_pts =
 +    avctx->pts_correction_num_faulty_dts = 0;
 +    avctx->pts_correction_last_pts =
 +    avctx->pts_correction_last_dts = INT64_MIN;
 +
      if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){
          ret = avctx->codec->init(avctx);
          if (ret < 0) {
              goto free_and_end;
          }
      }
 +
 +    ret=0;
  end:
      entangled_thread_counter--;
  
@@@ -746,44 -705,13 +748,44 @@@ int avcodec_encode_subtitle(AVCodecCont
          av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
          return -1;
      }
 -    if(sub->num_rects == 0 || !sub->rects)
 -        return -1;
 +
      ret = avctx->codec->encode(avctx, buf, buf_size, sub);
      avctx->frame_number++;
      return ret;
  }
  
 +/**
 + * Attempt to guess proper monotonic timestamps for decoded video frames
 + * which might have incorrect times. Input timestamps may wrap around, in
 + * which case the output will as well.
 + *
 + * @param pts the pts field of the decoded AVPacket, as passed through
 + * AVFrame.pkt_pts
 + * @param dts the dts field of the decoded AVPacket
 + * @return one of the input values, may be AV_NOPTS_VALUE
 + */
 +static int64_t guess_correct_pts(AVCodecContext *ctx,
 +                                 int64_t reordered_pts, int64_t dts)
 +{
 +    int64_t pts = AV_NOPTS_VALUE;
 +
 +    if (dts != AV_NOPTS_VALUE) {
 +        ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
 +        ctx->pts_correction_last_dts = dts;
 +    }
 +    if (reordered_pts != AV_NOPTS_VALUE) {
 +        ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
 +        ctx->pts_correction_last_pts = reordered_pts;
 +    }
 +    if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
 +       && reordered_pts != AV_NOPTS_VALUE)
 +        pts = reordered_pts;
 +    else
 +        pts = dts;
 +
 +    return pts;
 +}
 +
  int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
                           int *got_picture_ptr,
                           AVPacket *avpkt)
      if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
          return -1;
  
 -    avctx->pkt = avpkt;
 -
      if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){
 +        av_packet_split_side_data(avpkt);
 +        avctx->pkt = avpkt;
          if (HAVE_THREADS && avctx->active_thread_type&FF_THREAD_FRAME)
               ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
                                            avpkt);
              ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
                                avpkt);
              picture->pkt_dts= avpkt->dts;
 +
 +            if(!avctx->has_b_frames){
 +            picture->pkt_pos= avpkt->pos;
 +            }
 +            //FIXME these should be under if(!avctx->has_b_frames)
 +            if (!picture->sample_aspect_ratio.num)
 +                picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
 +            if (!picture->width)
 +                picture->width = avctx->width;
 +            if (!picture->height)
 +                picture->height = avctx->height;
 +            if (picture->format == PIX_FMT_NONE)
 +                picture->format = avctx->pix_fmt;
          }
  
          emms_c(); //needed to avoid an emms_c() call before every return;
  
 -        if (*got_picture_ptr)
 +
 +        if (*got_picture_ptr){
              avctx->frame_number++;
 +            picture->best_effort_timestamp = guess_correct_pts(avctx,
 +                                                            picture->pkt_pts,
 +                                                            picture->pkt_dts);
 +        }
      }else
          ret= 0;
  
@@@ -876,7 -786,6 +878,7 @@@ int avcodec_decode_subtitle2(AVCodecCon
  
      avctx->pkt = avpkt;
      *got_sub_ptr = 0;
 +    avcodec_get_subtitle_defaults(sub);
      ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
      if (*got_sub_ptr)
          avctx->frame_number++;
@@@ -973,18 -882,14 +975,18 @@@ AVCodec *avcodec_find_encoder_by_name(c
  
  AVCodec *avcodec_find_decoder(enum CodecID id)
  {
 -    AVCodec *p;
 +    AVCodec *p, *experimental=NULL;
      p = first_avcodec;
      while (p) {
 -        if (p->decode != NULL && p->id == id)
 -            return p;
 +        if (p->decode != NULL && p->id == id) {
 +            if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
 +                experimental = p;
 +            } else
 +                return p;
 +        }
          p = p->next;
      }
 -    return NULL;
 +    return experimental;
  }
  
  AVCodec *avcodec_find_decoder_by_name(const char *name)
@@@ -1024,25 -929,6 +1026,25 @@@ static int get_bit_rate(AVCodecContext 
      return bit_rate;
  }
  
 +const char *avcodec_get_name(enum CodecID id)
 +{
 +    AVCodec *codec;
 +
 +#if !CONFIG_SMALL
 +    switch (id) {
 +#include "libavcodec/codec_names.h"
 +    }
 +    av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
 +#endif
 +    codec = avcodec_find_decoder(id);
 +    if (codec)
 +        return codec->name;
 +    codec = avcodec_find_encoder(id);
 +    if (codec)
 +        return codec->name;
 +    return "unknown_codec";
 +}
 +
  size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
  {
      int i, len, ret = 0;
  
  void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
  {
 +    const char *codec_type;
      const char *codec_name;
      const char *profile = NULL;
      AVCodec *p;
 -    char buf1[32];
      int bitrate;
      AVRational display_aspect_ratio;
  
 -    if (encode)
 -        p = avcodec_find_encoder(enc->codec_id);
 -    else
 -        p = avcodec_find_decoder(enc->codec_id);
 -
 -    if (p) {
 -        codec_name = p->name;
 -        profile = av_get_profile_name(p, enc->profile);
 -    } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
 -        /* fake mpeg2 transport stream codec (currently not
 -           registered) */
 -        codec_name = "mpeg2ts";
 -    } else if (enc->codec_name[0] != '\0') {
 -        codec_name = enc->codec_name;
 -    } else {
 -        /* output avi tags */
 +    if (!buf || buf_size <= 0)
 +        return;
 +    codec_type = av_get_media_type_string(enc->codec_type);
 +    codec_name = avcodec_get_name(enc->codec_id);
 +    if (enc->profile != FF_PROFILE_UNKNOWN) {
 +        p = encode ? avcodec_find_encoder(enc->codec_id) :
 +                     avcodec_find_decoder(enc->codec_id);
 +        if (p)
 +            profile = av_get_profile_name(p, enc->profile);
 +    }
 +
 +    snprintf(buf, buf_size, "%s: %s%s", codec_type ? codec_type : "unknown",
 +             codec_name, enc->mb_decision ? " (hq)" : "");
 +    buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
 +    if (profile)
 +        snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
 +    if (enc->codec_tag) {
          char tag_buf[32];
          av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
 -        snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
 -        codec_name = buf1;
 +        snprintf(buf + strlen(buf), buf_size - strlen(buf),
 +                 " (%s / 0x%04X)", tag_buf, enc->codec_tag);
      }
 -
      switch(enc->codec_type) {
      case AVMEDIA_TYPE_VIDEO:
 -        snprintf(buf, buf_size,
 -                 "Video: %s%s",
 -                 codec_name, enc->mb_decision ? " (hq)" : "");
 -        if (profile)
 -            snprintf(buf + strlen(buf), buf_size - strlen(buf),
 -                     " (%s)", profile);
          if (enc->pix_fmt != PIX_FMT_NONE) {
              snprintf(buf + strlen(buf), buf_size - strlen(buf),
                       ", %s",
                            enc->height*enc->sample_aspect_ratio.den,
                            1024*1024);
                  snprintf(buf + strlen(buf), buf_size - strlen(buf),
 -                         " [PAR %d:%d DAR %d:%d]",
 +                         " [SAR %d:%d DAR %d:%d]",
                           enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
                           display_aspect_ratio.num, display_aspect_ratio.den);
              }
          }
          break;
      case AVMEDIA_TYPE_AUDIO:
 -        snprintf(buf, buf_size,
 -                 "Audio: %s",
 -                 codec_name);
 -        if (profile)
 -            snprintf(buf + strlen(buf), buf_size - strlen(buf),
 -                     " (%s)", profile);
          if (enc->sample_rate) {
              snprintf(buf + strlen(buf), buf_size - strlen(buf),
                       ", %d Hz", enc->sample_rate);
                       ", %s", av_get_sample_fmt_name(enc->sample_fmt));
          }
          break;
 -    case AVMEDIA_TYPE_DATA:
 -        snprintf(buf, buf_size, "Data: %s", codec_name);
 -        break;
 -    case AVMEDIA_TYPE_SUBTITLE:
 -        snprintf(buf, buf_size, "Subtitle: %s", codec_name);
 -        break;
 -    case AVMEDIA_TYPE_ATTACHMENT:
 -        snprintf(buf, buf_size, "Attachment: %s", codec_name);
 -        break;
      default:
 -        snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
          return;
      }
      if (encode) {
@@@ -1172,13 -1080,13 +1174,13 @@@ unsigned avcodec_version( void 
  
  const char *avcodec_configuration(void)
  {
 -    return LIBAV_CONFIGURATION;
 +    return FFMPEG_CONFIGURATION;
  }
  
  const char *avcodec_license(void)
  {
  #define LICENSE_PREFIX "libavcodec license: "
 -    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
  }
  
  void avcodec_flush_buffers(AVCodecContext *avctx)
@@@ -1296,7 -1204,7 +1298,7 @@@ int ff_match_2uint16(const uint16_t (*t
  
  void av_log_missing_feature(void *avc, const char *feature, int want_sample)
  {
 -    av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your Libav "
 +    av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg "
              "version to the newest one from Git. If the problem still "
              "occurs, it means that your file has a feature which has not "
              "been implemented.\n", feature);
@@@ -1313,8 -1221,8 +1315,8 @@@ void av_log_ask_for_sample(void *avc, c
      if (msg)
          av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
      av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
 -            "of this file to ftp://upload.libav.org/incoming/ "
 -            "and contact the libav-devel mailing list.\n");
 +            "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
 +            "and contact the ffmpeg-devel mailing list.\n");
  
      va_end(argument_list);
  }
@@@ -1376,9 -1284,6 +1378,9 @@@ unsigned int avpriv_toupper4(unsigned i
  int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
  {
      f->owner = avctx;
 +
 +    ff_init_buffer_info(avctx, f);
 +
      return avctx->get_buffer(avctx, f);
  }
  
diff --combined libavcodec/vp8.c
@@@ -5,20 -5,20 +5,20 @@@
   * Copyright (C) 2010 Ronald S. Bultje
   * Copyright (C) 2010 Jason Garrett-Glaser
   *
 - * 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
   */
  
@@@ -41,24 -41,57 +41,57 @@@ static void free_buffers(VP8Context *s
      av_freep(&s->top_nnz);
      av_freep(&s->edge_emu_buffer);
      av_freep(&s->top_border);
-     av_freep(&s->segmentation_map);
  
      s->macroblocks = NULL;
  }
  
- static void vp8_decode_flush(AVCodecContext *avctx)
+ static int vp8_alloc_frame(VP8Context *s, AVFrame *f)
+ {
+     int ret;
+     if ((ret = ff_thread_get_buffer(s->avctx, f)) < 0)
+         return ret;
+     if (!s->maps_are_invalid && s->num_maps_to_be_freed) {
+         f->ref_index[0] = s->segmentation_maps[--s->num_maps_to_be_freed];
+     } else if (!(f->ref_index[0] = av_mallocz(s->mb_width * s->mb_height))) {
+         ff_thread_release_buffer(s->avctx, f);
+         return AVERROR(ENOMEM);
+     }
+     return 0;
+ }
+ static void vp8_release_frame(VP8Context *s, AVFrame *f, int is_close)
+ {
+     if (!is_close) {
+         if (f->ref_index[0]) {
+             assert(s->num_maps_to_be_freed < FF_ARRAY_ELEMS(s->segmentation_maps));
+             s->segmentation_maps[s->num_maps_to_be_freed++] = f->ref_index[0];
+             f->ref_index[0] = NULL;
+         }
+     } else {
+         av_freep(&f->ref_index[0]);
+     }
+     ff_thread_release_buffer(s->avctx, f);
+ }
+ static void vp8_decode_flush_impl(AVCodecContext *avctx, int force, int is_close)
  {
      VP8Context *s = avctx->priv_data;
      int i;
  
-     if (!avctx->is_copy) {
+     if (!avctx->is_copy || force) {
          for (i = 0; i < 5; i++)
              if (s->frames[i].data[0])
-                 ff_thread_release_buffer(avctx, &s->frames[i]);
+                 vp8_release_frame(s, &s->frames[i], is_close);
      }
      memset(s->framep, 0, sizeof(s->framep));
  
      free_buffers(s);
+     s->maps_are_invalid = 1;
+ }
+ static void vp8_decode_flush(AVCodecContext *avctx)
+ {
+     vp8_decode_flush_impl(avctx, 0, 0);
  }
  
  static int update_dimensions(VP8Context *s, int width, int height)
          if (av_image_check_size(width, height, 0, s->avctx))
              return AVERROR_INVALIDDATA;
  
-         vp8_decode_flush(s->avctx);
+         vp8_decode_flush_impl(s->avctx, 1, 0);
  
          avcodec_set_dimensions(s->avctx, width, height);
      }
      s->intra4x4_pred_mode_top  = av_mallocz(s->mb_width*4);
      s->top_nnz                 = av_mallocz(s->mb_width*sizeof(*s->top_nnz));
      s->top_border              = av_mallocz((s->mb_width+1)*sizeof(*s->top_border));
-     s->segmentation_map        = av_mallocz(s->mb_width*s->mb_height);
  
      if (!s->macroblocks_base || !s->filter_strength || !s->intra4x4_pred_mode_top ||
-         !s->top_nnz || !s->top_border || !s->segmentation_map)
+         !s->top_nnz || !s->top_border)
          return AVERROR(ENOMEM);
  
      s->macroblocks        = s->macroblocks_base + 1;
@@@ -1508,6 -1540,14 +1540,14 @@@ static void filter_mb_row_simple(VP8Con
      }
  }
  
+ static void release_queued_segmaps(VP8Context *s, int is_close)
+ {
+     int leave_behind = is_close ? 0 : !s->maps_are_invalid;
+     while (s->num_maps_to_be_freed > leave_behind)
+         av_freep(&s->segmentation_maps[--s->num_maps_to_be_freed]);
+     s->maps_are_invalid = 0;
+ }
  static int vp8_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
                              AVPacket *avpkt)
  {
      enum AVDiscard skip_thresh;
      AVFrame *av_uninit(curframe), *prev_frame = s->framep[VP56_FRAME_CURRENT];
  
+     release_queued_segmaps(s, 0);
      if ((ret = decode_frame_header(s, avpkt->data, avpkt->size)) < 0)
          return ret;
  
              &s->frames[i] != s->framep[VP56_FRAME_PREVIOUS] &&
              &s->frames[i] != s->framep[VP56_FRAME_GOLDEN] &&
              &s->frames[i] != s->framep[VP56_FRAME_GOLDEN2])
-             ff_thread_release_buffer(avctx, &s->frames[i]);
+             vp8_release_frame(s, &s->frames[i], 0);
  
      // find a free buffer
      for (i = 0; i < 5; i++)
      curframe->key_frame = s->keyframe;
      curframe->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
      curframe->reference = referenced ? 3 : 0;
-     curframe->ref_index[0] = s->segmentation_map;
-     if ((ret = ff_thread_get_buffer(avctx, curframe))) {
+     if ((ret = vp8_alloc_frame(s, curframe))) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed!\n");
          return ret;
      }
              s->dsp.prefetch(dst[0] + (mb_x&3)*4*s->linesize + 64, s->linesize, 4);
              s->dsp.prefetch(dst[1] + (mb_x&7)*s->uvlinesize + 64, dst[2] - dst[1], 2);
  
-             decode_mb_mode(s, mb, mb_x, mb_y, s->segmentation_map + mb_xy,
-                            prev_frame ? prev_frame->ref_index[0] + mb_xy : NULL);
+             decode_mb_mode(s, mb, mb_x, mb_y, curframe->ref_index[0] + mb_xy,
+                            prev_frame && prev_frame->ref_index[0] ? prev_frame->ref_index[0] + mb_xy : NULL);
  
              prefetch_motion(s, mb, mb_x, mb_y, mb_xy, VP56_FRAME_PREVIOUS);
  
@@@ -1736,7 -1777,8 +1777,8 @@@ static av_cold int vp8_decode_init(AVCo
  
  static av_cold int vp8_decode_free(AVCodecContext *avctx)
  {
-     vp8_decode_flush(avctx);
+     vp8_decode_flush_impl(avctx, 0, 1);
+     release_queued_segmaps(avctx->priv_data, 1);
      return 0;
  }
  
diff --combined libavcodec/vp8.h
@@@ -5,20 -5,20 +5,20 @@@
   * Copyright (C) 2010 Ronald S. Bultje
   * Copyright (C) 2010 Jason Garrett-Glaser
   *
 - * 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
   */
  
@@@ -130,7 -130,6 +130,6 @@@ typedef struct 
  
      uint8_t *intra4x4_pred_mode_top;
      uint8_t intra4x4_pred_mode_left[4];
-     uint8_t *segmentation_map;
  
      /**
       * Macroblocks can have one of 4 different quants in a frame when
      H264PredContext hpc;
      vp8_mc_func put_pixels_tab[3][3][3];
      AVFrame frames[5];
+     /**
+      * A list of segmentation_map buffers that are to be free()'ed in
+      * the next decoding iteration. We can't free() them right away
+      * because the map may still be used by subsequent decoding threads.
+      * Unused if frame threading is off.
+      */
+     uint8_t *segmentation_maps[5];
+     int num_maps_to_be_freed;
+     int maps_are_invalid;
  } VP8Context;
  
  #endif /* AVCODEC_VP8_H */
@@@ -2,24 -2,24 +2,24 @@@
  ;* MMX optimized DSP utils
  ;* Copyright (c) 2008 Loren Merritt
  ;*
 -;* 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 "x86inc.asm"
 +%include "libavutil/x86/x86inc.asm"
  %include "x86util.asm"
  
  SECTION_RODATA
@@@ -1055,14 -1055,6 +1055,6 @@@ emu_edge mm
  ;                           int32_t max, unsigned int len)
  ;-----------------------------------------------------------------------------
  
- %macro SPLATD_MMX 1
-     punpckldq  %1, %1
- %endmacro
- %macro SPLATD_SSE2 1
-     pshufd  %1, %1, 0
- %endmacro
  %macro VECTOR_CLIP_INT32 4
  cglobal vector_clip_int32_%1, 5,5,%2, dst, src, min, max, len
  %ifidn %1, sse2
  ;* x86 optimized Format Conversion Utils
  ;* Copyright (c) 2008 Loren Merritt
  ;*
 -;* 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 "x86inc.asm"
 -%include "x86util.asm"
 +%include "libavutil/x86/x86inc.asm"
 +%include "libavutil/x86/x86util.asm"
  
  SECTION_TEXT
  
+ ;---------------------------------------------------------------------------------
+ ; void int32_to_float_fmul_scalar(float *dst, const int *src, float mul, int len);
+ ;---------------------------------------------------------------------------------
+ %macro INT32_TO_FLOAT_FMUL_SCALAR 2
+ %ifdef ARCH_X86_64
+ cglobal int32_to_float_fmul_scalar_%1, 3,3,%2, dst, src, len
+ %else
+ cglobal int32_to_float_fmul_scalar_%1, 4,4,%2, dst, src, mul, len
+     movss   m0, mulm
+ %endif
+     SPLATD  m0
+     shl     lenq, 2
+     add     srcq, lenq
+     add     dstq, lenq
+     neg     lenq
+ .loop:
+ %ifidn %1, sse2
+     cvtdq2ps  m1, [srcq+lenq   ]
+     cvtdq2ps  m2, [srcq+lenq+16]
+ %else
+     cvtpi2ps  m1, [srcq+lenq   ]
+     cvtpi2ps  m3, [srcq+lenq+ 8]
+     cvtpi2ps  m2, [srcq+lenq+16]
+     cvtpi2ps  m4, [srcq+lenq+24]
+     movlhps   m1, m3
+     movlhps   m2, m4
+ %endif
+     mulps     m1, m0
+     mulps     m2, m0
+     mova  [dstq+lenq   ], m1
+     mova  [dstq+lenq+16], m2
+     add     lenq, 32
+     jl .loop
+     REP_RET
+ %endmacro
+ INIT_XMM
+ %define SPLATD SPLATD_SSE
+ %define movdqa movaps
+ INT32_TO_FLOAT_FMUL_SCALAR sse, 5
+ %undef movdqa
+ %define SPLATD SPLATD_SSE2
+ INT32_TO_FLOAT_FMUL_SCALAR sse2, 3
+ %undef SPLATD
+ ;------------------------------------------------------------------------------
+ ; void ff_float_to_int16(int16_t *dst, const float *src, long len);
+ ;------------------------------------------------------------------------------
+ %macro FLOAT_TO_INT16 2
+ cglobal float_to_int16_%1, 3,3,%2, dst, src, len
+     add       lenq, lenq
+     lea       srcq, [srcq+2*lenq]
+     add       dstq, lenq
+     neg       lenq
+ .loop:
+ %ifidn %1, sse2
+     cvtps2dq    m0, [srcq+2*lenq   ]
+     cvtps2dq    m1, [srcq+2*lenq+16]
+     packssdw    m0, m1
+     mova  [dstq+lenq], m0
+ %else
+     cvtps2pi    m0, [srcq+2*lenq   ]
+     cvtps2pi    m1, [srcq+2*lenq+ 8]
+     cvtps2pi    m2, [srcq+2*lenq+16]
+     cvtps2pi    m3, [srcq+2*lenq+24]
+     packssdw    m0, m1
+     packssdw    m2, m3
+     mova  [dstq+lenq  ], m0
+     mova  [dstq+lenq+8], m2
+ %endif
+     add       lenq, 16
+     js .loop
+ %ifnidn %1, sse2
+     emms
+ %endif
+     REP_RET
+ %endmacro
+ INIT_XMM
+ FLOAT_TO_INT16 sse2, 2
+ INIT_MMX
+ FLOAT_TO_INT16 sse, 0
+ %define cvtps2pi pf2id
+ FLOAT_TO_INT16 3dnow, 0
+ %undef cvtps2pi
+ ;-------------------------------------------------------------------------------
+ ; void ff_float_to_int16_interleave2(int16_t *dst, const float **src, long len);
+ ;-------------------------------------------------------------------------------
+ %macro FLOAT_TO_INT16_INTERLEAVE2 1
+ cglobal float_to_int16_interleave2_%1, 3,4,2, dst, src0, src1, len
+     lea      lenq, [4*r2q]
+     mov     src1q, [src0q+gprsize]
+     mov     src0q, [src0q]
+     add      dstq, lenq
+     add     src0q, lenq
+     add     src1q, lenq
+     neg      lenq
+ .loop:
+ %ifidn %1, sse2
+     cvtps2dq   m0, [src0q+lenq]
+     cvtps2dq   m1, [src1q+lenq]
+     packssdw   m0, m1
+     movhlps    m1, m0
+     punpcklwd  m0, m1
+     mova  [dstq+lenq], m0
+ %else
+     cvtps2pi   m0, [src0q+lenq  ]
+     cvtps2pi   m1, [src0q+lenq+8]
+     cvtps2pi   m2, [src1q+lenq  ]
+     cvtps2pi   m3, [src1q+lenq+8]
+     packssdw   m0, m1
+     packssdw   m2, m3
+     mova       m1, m0
+     punpcklwd  m0, m2
+     punpckhwd  m1, m2
+     mova  [dstq+lenq  ], m0
+     mova  [dstq+lenq+8], m1
+ %endif
+     add      lenq, 16
+     js .loop
+ %ifnidn %1, sse2
+     emms
+ %endif
+     REP_RET
+ %endmacro
+ INIT_MMX
+ %define cvtps2pi pf2id
+ FLOAT_TO_INT16_INTERLEAVE2 3dnow
+ %undef cvtps2pi
+ %define movdqa movaps
+ FLOAT_TO_INT16_INTERLEAVE2 sse
+ %undef movdqa
+ INIT_XMM
+ FLOAT_TO_INT16_INTERLEAVE2 sse2
  %macro PSWAPD_SSE 2
      pshufw %1, %2, 0x4e
  %endmacro
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2000, 2001 Fabrice Bellard
   * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   *
   * MMX optimization by Nick Kurshev <nickols_k@mail.ru>
  #include "libavutil/x86_cpu.h"
  #include "libavcodec/fmtconvert.h"
  
- static void int32_to_float_fmul_scalar_sse(float *dst, const int *src, float mul, int len)
- {
-     x86_reg i = -4*len;
-     __asm__ volatile(
-         "movss  %3, %%xmm4 \n"
-         "shufps $0, %%xmm4, %%xmm4 \n"
-         "1: \n"
-         "cvtpi2ps   (%2,%0), %%xmm0 \n"
-         "cvtpi2ps  8(%2,%0), %%xmm1 \n"
-         "cvtpi2ps 16(%2,%0), %%xmm2 \n"
-         "cvtpi2ps 24(%2,%0), %%xmm3 \n"
-         "movlhps  %%xmm1,    %%xmm0 \n"
-         "movlhps  %%xmm3,    %%xmm2 \n"
-         "mulps    %%xmm4,    %%xmm0 \n"
-         "mulps    %%xmm4,    %%xmm2 \n"
-         "movaps   %%xmm0,   (%1,%0) \n"
-         "movaps   %%xmm2, 16(%1,%0) \n"
-         "add $32, %0 \n"
-         "jl 1b \n"
-         :"+r"(i)
-         :"r"(dst+len), "r"(src+len), "m"(mul)
-     );
- }
- static void int32_to_float_fmul_scalar_sse2(float *dst, const int *src, float mul, int len)
- {
-     x86_reg i = -4*len;
-     __asm__ volatile(
-         "movss  %3, %%xmm4 \n"
-         "shufps $0, %%xmm4, %%xmm4 \n"
-         "1: \n"
-         "cvtdq2ps   (%2,%0), %%xmm0 \n"
-         "cvtdq2ps 16(%2,%0), %%xmm1 \n"
-         "mulps    %%xmm4,    %%xmm0 \n"
-         "mulps    %%xmm4,    %%xmm1 \n"
-         "movaps   %%xmm0,   (%1,%0) \n"
-         "movaps   %%xmm1, 16(%1,%0) \n"
-         "add $32, %0 \n"
-         "jl 1b \n"
-         :"+r"(i)
-         :"r"(dst+len), "r"(src+len), "m"(mul)
-     );
- }
+ #if HAVE_YASM
  
- static void float_to_int16_3dnow(int16_t *dst, const float *src, long len){
-     x86_reg reglen = len;
-     // not bit-exact: pf2id uses different rounding than C and SSE
-     __asm__ volatile(
-         "add        %0          , %0        \n\t"
-         "lea         (%2,%0,2)  , %2        \n\t"
-         "add        %0          , %1        \n\t"
-         "neg        %0                      \n\t"
-         "1:                                 \n\t"
-         "pf2id       (%2,%0,2)  , %%mm0     \n\t"
-         "pf2id      8(%2,%0,2)  , %%mm1     \n\t"
-         "pf2id     16(%2,%0,2)  , %%mm2     \n\t"
-         "pf2id     24(%2,%0,2)  , %%mm3     \n\t"
-         "packssdw   %%mm1       , %%mm0     \n\t"
-         "packssdw   %%mm3       , %%mm2     \n\t"
-         "movq       %%mm0       ,  (%1,%0)  \n\t"
-         "movq       %%mm2       , 8(%1,%0)  \n\t"
-         "add        $16         , %0        \n\t"
-         " js 1b                             \n\t"
-         "femms                              \n\t"
-         :"+r"(reglen), "+r"(dst), "+r"(src)
-     );
- }
+ void ff_int32_to_float_fmul_scalar_sse (float *dst, const int *src, float mul, int len);
+ void ff_int32_to_float_fmul_scalar_sse2(float *dst, const int *src, float mul, int len);
  
- static void float_to_int16_sse(int16_t *dst, const float *src, long len){
-     x86_reg reglen = len;
-     __asm__ volatile(
-         "add        %0          , %0        \n\t"
-         "lea         (%2,%0,2)  , %2        \n\t"
-         "add        %0          , %1        \n\t"
-         "neg        %0                      \n\t"
-         "1:                                 \n\t"
-         "cvtps2pi    (%2,%0,2)  , %%mm0     \n\t"
-         "cvtps2pi   8(%2,%0,2)  , %%mm1     \n\t"
-         "cvtps2pi  16(%2,%0,2)  , %%mm2     \n\t"
-         "cvtps2pi  24(%2,%0,2)  , %%mm3     \n\t"
-         "packssdw   %%mm1       , %%mm0     \n\t"
-         "packssdw   %%mm3       , %%mm2     \n\t"
-         "movq       %%mm0       ,  (%1,%0)  \n\t"
-         "movq       %%mm2       , 8(%1,%0)  \n\t"
-         "add        $16         , %0        \n\t"
-         " js 1b                             \n\t"
-         "emms                               \n\t"
-         :"+r"(reglen), "+r"(dst), "+r"(src)
-     );
- }
+ void ff_float_to_int16_3dnow(int16_t *dst, const float *src, long len);
+ void ff_float_to_int16_sse  (int16_t *dst, const float *src, long len);
+ void ff_float_to_int16_sse2 (int16_t *dst, const float *src, long len);
  
- static void float_to_int16_sse2(int16_t *dst, const float *src, long len){
-     x86_reg reglen = len;
-     __asm__ volatile(
-         "add        %0          , %0        \n\t"
-         "lea         (%2,%0,2)  , %2        \n\t"
-         "add        %0          , %1        \n\t"
-         "neg        %0                      \n\t"
-         "1:                                 \n\t"
-         "cvtps2dq    (%2,%0,2)  , %%xmm0    \n\t"
-         "cvtps2dq  16(%2,%0,2)  , %%xmm1    \n\t"
-         "packssdw   %%xmm1      , %%xmm0    \n\t"
-         "movdqa     %%xmm0      ,  (%1,%0)  \n\t"
-         "add        $16         , %0        \n\t"
-         " js 1b                             \n\t"
-         :"+r"(reglen), "+r"(dst), "+r"(src)
-     );
- }
+ void ff_float_to_int16_interleave2_3dnow(int16_t *dst, const float **src, long len);
+ void ff_float_to_int16_interleave2_sse  (int16_t *dst, const float **src, long len);
+ void ff_float_to_int16_interleave2_sse2 (int16_t *dst, const float **src, long len);
  
  void ff_float_to_int16_interleave6_sse(int16_t *dst, const float **src, int len);
  void ff_float_to_int16_interleave6_3dnow(int16_t *dst, const float **src, int len);
  void ff_float_to_int16_interleave6_3dn2(int16_t *dst, const float **src, int len);
  
- #if !HAVE_YASM
- #define ff_float_to_int16_interleave6_sse(a,b,c)   float_to_int16_interleave_misc_sse(a,b,c,6)
- #define ff_float_to_int16_interleave6_3dnow(a,b,c) float_to_int16_interleave_misc_3dnow(a,b,c,6)
- #define ff_float_to_int16_interleave6_3dn2(a,b,c)  float_to_int16_interleave_misc_3dnow(a,b,c,6)
- #endif
  #define ff_float_to_int16_interleave6_sse2 ff_float_to_int16_interleave6_sse
  
- #define FLOAT_TO_INT16_INTERLEAVE(cpu, body) \
+ #define FLOAT_TO_INT16_INTERLEAVE(cpu) \
  /* gcc pessimizes register allocation if this is in the same function as float_to_int16_interleave_sse2*/\
  static av_noinline void float_to_int16_interleave_misc_##cpu(int16_t *dst, const float **src, long len, int channels){\
      DECLARE_ALIGNED(16, int16_t, tmp)[len];\
      int i,j,c;\
      for(c=0; c<channels; c++){\
-         float_to_int16_##cpu(tmp, src[c], len);\
+         ff_float_to_int16_##cpu(tmp, src[c], len);\
          for(i=0, j=c; i<len; i++, j+=channels)\
              dst[j] = tmp[i];\
      }\
  \
  static void float_to_int16_interleave_##cpu(int16_t *dst, const float **src, long len, int channels){\
      if(channels==1)\
-         float_to_int16_##cpu(dst, src[0], len);\
+         ff_float_to_int16_##cpu(dst, src[0], len);\
      else if(channels==2){\
-         x86_reg reglen = len; \
-         const float *src0 = src[0];\
-         const float *src1 = src[1];\
-         __asm__ volatile(\
-             "shl $2, %0 \n"\
-             "add %0, %1 \n"\
-             "add %0, %2 \n"\
-             "add %0, %3 \n"\
-             "neg %0 \n"\
-             body\
-             :"+r"(reglen), "+r"(dst), "+r"(src0), "+r"(src1)\
-         );\
+         ff_float_to_int16_interleave2_##cpu(dst, src, len);\
      }else if(channels==6){\
          ff_float_to_int16_interleave6_##cpu(dst, src, len);\
      }else\
          float_to_int16_interleave_misc_##cpu(dst, src, len, channels);\
  }
  
- FLOAT_TO_INT16_INTERLEAVE(3dnow,
-     "1:                         \n"
-     "pf2id     (%2,%0), %%mm0   \n"
-     "pf2id    8(%2,%0), %%mm1   \n"
-     "pf2id     (%3,%0), %%mm2   \n"
-     "pf2id    8(%3,%0), %%mm3   \n"
-     "packssdw    %%mm1, %%mm0   \n"
-     "packssdw    %%mm3, %%mm2   \n"
-     "movq        %%mm0, %%mm1   \n"
-     "punpcklwd   %%mm2, %%mm0   \n"
-     "punpckhwd   %%mm2, %%mm1   \n"
-     "movq        %%mm0,  (%1,%0)\n"
-     "movq        %%mm1, 8(%1,%0)\n"
-     "add $16, %0                \n"
-     "js 1b                      \n"
-     "femms                      \n"
- )
- FLOAT_TO_INT16_INTERLEAVE(sse,
-     "1:                         \n"
-     "cvtps2pi  (%2,%0), %%mm0   \n"
-     "cvtps2pi 8(%2,%0), %%mm1   \n"
-     "cvtps2pi  (%3,%0), %%mm2   \n"
-     "cvtps2pi 8(%3,%0), %%mm3   \n"
-     "packssdw    %%mm1, %%mm0   \n"
-     "packssdw    %%mm3, %%mm2   \n"
-     "movq        %%mm0, %%mm1   \n"
-     "punpcklwd   %%mm2, %%mm0   \n"
-     "punpckhwd   %%mm2, %%mm1   \n"
-     "movq        %%mm0,  (%1,%0)\n"
-     "movq        %%mm1, 8(%1,%0)\n"
-     "add $16, %0                \n"
-     "js 1b                      \n"
-     "emms                       \n"
- )
- FLOAT_TO_INT16_INTERLEAVE(sse2,
-     "1:                         \n"
-     "cvtps2dq  (%2,%0), %%xmm0  \n"
-     "cvtps2dq  (%3,%0), %%xmm1  \n"
-     "packssdw   %%xmm1, %%xmm0  \n"
-     "movhlps    %%xmm0, %%xmm1  \n"
-     "punpcklwd  %%xmm1, %%xmm0  \n"
-     "movdqa     %%xmm0, (%1,%0) \n"
-     "add $16, %0                \n"
-     "js 1b                      \n"
- )
+ FLOAT_TO_INT16_INTERLEAVE(3dnow)
+ FLOAT_TO_INT16_INTERLEAVE(sse)
+ FLOAT_TO_INT16_INTERLEAVE(sse2)
  
  static void float_to_int16_interleave_3dn2(int16_t *dst, const float **src, long len, int channels){
      if(channels==6)
          float_to_int16_interleave_3dnow(dst, src, len, channels);
  }
  
- #if HAVE_YASM
  void ff_float_interleave2_mmx(float *dst, const float **src, unsigned int len);
  void ff_float_interleave2_sse(float *dst, const float **src, unsigned int len);
  
@@@ -269,34 -112,32 +112,32 @@@ void ff_fmt_convert_init_x86(FmtConvert
  {
      int mm_flags = av_get_cpu_flags();
  
-     if (mm_flags & AV_CPU_FLAG_MMX) {
  #if HAVE_YASM
+     if (mm_flags & AV_CPU_FLAG_MMX) {
          c->float_interleave = float_interleave_mmx;
- #endif
  
-         if(mm_flags & AV_CPU_FLAG_3DNOW){
+         if (HAVE_AMD3DNOW && mm_flags & AV_CPU_FLAG_3DNOW) {
              if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
-                 c->float_to_int16 = float_to_int16_3dnow;
+                 c->float_to_int16 = ff_float_to_int16_3dnow;
                  c->float_to_int16_interleave = float_to_int16_interleave_3dnow;
              }
          }
-         if(mm_flags & AV_CPU_FLAG_3DNOWEXT){
+         if (HAVE_AMD3DNOWEXT && mm_flags & AV_CPU_FLAG_3DNOWEXT) {
              if(!(avctx->flags & CODEC_FLAG_BITEXACT)){
                  c->float_to_int16_interleave = float_to_int16_interleave_3dn2;
              }
          }
-         if(mm_flags & AV_CPU_FLAG_SSE){
-             c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse;
-             c->float_to_int16 = float_to_int16_sse;
+         if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE) {
+             c->int32_to_float_fmul_scalar = ff_int32_to_float_fmul_scalar_sse;
+             c->float_to_int16 = ff_float_to_int16_sse;
              c->float_to_int16_interleave = float_to_int16_interleave_sse;
- #if HAVE_YASM
              c->float_interleave = float_interleave_sse;
- #endif
          }
-         if(mm_flags & AV_CPU_FLAG_SSE2){
-             c->int32_to_float_fmul_scalar = int32_to_float_fmul_scalar_sse2;
-             c->float_to_int16 = float_to_int16_sse2;
+         if (HAVE_SSE && mm_flags & AV_CPU_FLAG_SSE2) {
+             c->int32_to_float_fmul_scalar = ff_int32_to_float_fmul_scalar_sse2;
+             c->float_to_int16 = ff_float_to_int16_sse2;
              c->float_to_int16_interleave = float_to_int16_interleave_sse2;
          }
      }
+ #endif
  }
@@@ -4,45 -4,44 +4,44 @@@
  ;* Copyright (c) 2004-2005 Michael Niedermayer, Loren Merritt
  ;* Copyright (C) 2010 Eli Friedman <eli.friedman@gmail.com>
  ;*
 -;* 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 "x86inc.asm"
 +%include "libavutil/x86/x86inc.asm"
  
  SECTION .text
  
  ;-----------------------------------------------------------------------------
  ; biweight pred:
  ;
- ; void h264_biweight_16x16_sse2(uint8_t *dst, uint8_t *src, int stride,
- ;                               int log2_denom, int weightd, int weights,
- ;                               int offset);
+ ; void h264_biweight_16_sse2(uint8_t *dst, uint8_t *src, int stride,
+ ;                            int height, int log2_denom, int weightd,
+ ;                            int weights, int offset);
  ; and
- ; void h264_weight_16x16_sse2(uint8_t *dst, int stride,
- ;                             int log2_denom, int weight,
- ;                             int offset);
+ ; void h264_weight_16_sse2(uint8_t *dst, int stride, int height,
+ ;                          int log2_denom, int weight, int offset);
  ;-----------------------------------------------------------------------------
  
  %macro WEIGHT_SETUP 0
-     add        r4, r4
-     inc        r4
-     movd       m3, r3d
-     movd       m5, r4d
-     movd       m6, r2d
+     add        r5, r5
+     inc        r5
+     movd       m3, r4d
+     movd       m5, r5d
+     movd       m6, r3d
      pslld      m5, m6
      psrld      m5, 1
  %if mmsize == 16
      packuswb      m0, m1
  %endmacro
  
- %macro WEIGHT_FUNC_DBL_MM 1
- cglobal h264_weight_16x%1_mmx2, 5, 5, 0
+ INIT_MMX
+ cglobal h264_weight_16_mmx2, 6, 6, 0
      WEIGHT_SETUP
-     mov        r2, %1
- %if %1 == 16
  .nextrow
      WEIGHT_OP 0,  4
      mova     [r0  ], m0
      WEIGHT_OP 8, 12
      mova     [r0+8], m0
      add        r0, r1
-     dec        r2
+     dec        r2d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_weight_16x16_mmx2.nextrow)
- %endif
- %endmacro
  
- INIT_MMX
- WEIGHT_FUNC_DBL_MM 16
- WEIGHT_FUNC_DBL_MM  8
- %macro WEIGHT_FUNC_MM 4
- cglobal h264_weight_%1x%2_%4, 7, 7, %3
+ %macro WEIGHT_FUNC_MM 3
+ cglobal h264_weight_%1_%3, 6, 6, %2
      WEIGHT_SETUP
-     mov        r2, %2
- %if %2 == 16
  .nextrow
      WEIGHT_OP 0, mmsize/2
      mova     [r0], m0
      add        r0, r1
-     dec        r2
+     dec        r2d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_weight_%1x16_%4.nextrow)
- %endif
  %endmacro
  
  INIT_MMX
- WEIGHT_FUNC_MM  8, 16,  0, mmx2
- WEIGHT_FUNC_MM  8,  8,  0, mmx2
- WEIGHT_FUNC_MM  8,  4,  0, mmx2
+ WEIGHT_FUNC_MM  8, 0, mmx2
  INIT_XMM
- WEIGHT_FUNC_MM 16, 16,  8, sse2
- WEIGHT_FUNC_MM 16,  8,  8, sse2
+ WEIGHT_FUNC_MM 16, 8, sse2
  
- %macro WEIGHT_FUNC_HALF_MM 5
- cglobal h264_weight_%1x%2_%5, 5, 5, %4
+ %macro WEIGHT_FUNC_HALF_MM 3
+ cglobal h264_weight_%1_%3, 6, 6, %2
      WEIGHT_SETUP
-     mov        r2, %2/2
+     sar       r2d, 1
      lea        r3, [r1*2]
- %if %2 == mmsize
  .nextrow
      WEIGHT_OP 0, r1
      movh     [r0], m0
      movh     [r0+r1], m0
  %endif
      add        r0, r3
-     dec        r2
+     dec        r2d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_weight_%1x%3_%5.nextrow)
- %endif
  %endmacro
  
  INIT_MMX
- WEIGHT_FUNC_HALF_MM 4,  8,  8, 0, mmx2
- WEIGHT_FUNC_HALF_MM 4,  4,  8, 0, mmx2
- WEIGHT_FUNC_HALF_MM 4,  2,  8, 0, mmx2
+ WEIGHT_FUNC_HALF_MM 4, 0, mmx2
+ WEIGHT_FUNC_HALF_MM 4, 0, mmx2
+ WEIGHT_FUNC_HALF_MM 4, 0, mmx2
  INIT_XMM
- WEIGHT_FUNC_HALF_MM 8, 16, 16, 8, sse2
- WEIGHT_FUNC_HALF_MM 8,  8, 16, 8, sse2
- WEIGHT_FUNC_HALF_MM 8,  4, 16, 8, sse2
+ WEIGHT_FUNC_HALF_MM 8, 8, sse2
+ WEIGHT_FUNC_HALF_MM 8, 8, sse2
+ WEIGHT_FUNC_HALF_MM 8, 8, sse2
  
  %macro BIWEIGHT_SETUP 0
-     add        r6, 1
-     or         r6, 1
-     add        r3, 1
-     movd       m3, r4d
-     movd       m4, r5d
-     movd       m5, r6d
-     movd       m6, r3d
+ %ifdef ARCH_X86_64
+ %define off_regd r11d
+ %else
+ %define off_regd r3d
+ %endif
+     mov  off_regd, r7m
+     add  off_regd, 1
+     or   off_regd, 1
+     add        r4, 1
+     movd       m3, r5d
+     movd       m4, r6d
+     movd       m5, off_regd
+     movd       m6, r4d
      pslld      m5, m6
      psrld      m5, 1
  %if mmsize == 16
      packuswb   m0, m1
  %endmacro
  
- %macro BIWEIGHT_FUNC_DBL_MM 1
- cglobal h264_biweight_16x%1_mmx2, 7, 7, 0
+ INIT_MMX
+ cglobal h264_biweight_16_mmx2, 7, 7, 0
      BIWEIGHT_SETUP
-     mov        r3, %1
- %if %1 == 16
+     movifnidn r3d, r3m
  .nextrow
      BIWEIGHT_STEPA 0, 1, 0
      BIWEIGHT_STEPA 1, 2, 4
      mova     [r0+8], m0
      add        r0, r2
      add        r1, r2
-     dec        r3
+     dec        r3d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_biweight_16x16_mmx2.nextrow)
- %endif
- %endmacro
  
- INIT_MMX
- BIWEIGHT_FUNC_DBL_MM 16
- BIWEIGHT_FUNC_DBL_MM  8
- %macro BIWEIGHT_FUNC_MM 4
- cglobal h264_biweight_%1x%2_%4, 7, 7, %3
+ %macro BIWEIGHT_FUNC_MM 3
+ cglobal h264_biweight_%1_%3, 7, 7, %2
      BIWEIGHT_SETUP
-     mov        r3, %2
- %if %2 == 16
+     movifnidn r3d, r3m
  .nextrow
      BIWEIGHT_STEPA 0, 1, 0
      BIWEIGHT_STEPA 1, 2, mmsize/2
      mova       [r0], m0
      add        r0, r2
      add        r1, r2
-     dec        r3
+     dec        r3d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_biweight_%1x16_%4.nextrow)
- %endif
  %endmacro
  
  INIT_MMX
- BIWEIGHT_FUNC_MM  8, 16,  0, mmx2
- BIWEIGHT_FUNC_MM  8,  8,  0, mmx2
- BIWEIGHT_FUNC_MM  8,  4,  0, mmx2
+ BIWEIGHT_FUNC_MM  8, 0, mmx2
  INIT_XMM
- BIWEIGHT_FUNC_MM 16, 16,  8, sse2
- BIWEIGHT_FUNC_MM 16,  8,  8, sse2
+ BIWEIGHT_FUNC_MM 16, 8, sse2
  
- %macro BIWEIGHT_FUNC_HALF_MM 5
- cglobal h264_biweight_%1x%2_%5, 7, 7, %4
+ %macro BIWEIGHT_FUNC_HALF_MM 3
+ cglobal h264_biweight_%1_%3, 7, 7, %2
      BIWEIGHT_SETUP
-     mov        r3, %2/2
+     movifnidn r3d, r3m
+     sar        r3, 1
      lea        r4, [r2*2]
- %if %2 == mmsize
  .nextrow
      BIWEIGHT_STEPA 0, 1, 0
      BIWEIGHT_STEPA 1, 2, r2
  %endif
      add        r0, r4
      add        r1, r4
-     dec        r3
+     dec        r3d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_biweight_%1x%3_%5.nextrow)
- %endif
  %endmacro
  
  INIT_MMX
- BIWEIGHT_FUNC_HALF_MM 4,  8,  8, 0, mmx2
- BIWEIGHT_FUNC_HALF_MM 4,  4,  8, 0, mmx2
- BIWEIGHT_FUNC_HALF_MM 4,  2,  8, 0, mmx2
+ BIWEIGHT_FUNC_HALF_MM 4, 0, mmx2
  INIT_XMM
- BIWEIGHT_FUNC_HALF_MM 8, 16, 16, 8, sse2
- BIWEIGHT_FUNC_HALF_MM 8,  8, 16, 8, sse2
- BIWEIGHT_FUNC_HALF_MM 8,  4, 16, 8, sse2
+ BIWEIGHT_FUNC_HALF_MM 8, 8, sse2
  
  %macro BIWEIGHT_SSSE3_SETUP 0
-     add        r6, 1
-     or         r6, 1
-     add        r3, 1
-     movd       m4, r4d
-     movd       m0, r5d
-     movd       m5, r6d
-     movd       m6, r3d
+ %ifdef ARCH_X86_64
+ %define off_regd r11d
+ %else
+ %define off_regd r3d
+ %endif
+     mov  off_regd, r7m
+     add  off_regd, 1
+     or   off_regd, 1
+     add        r4, 1
+     movd       m4, r5d
+     movd       m0, r6d
+     movd       m5, off_regd
+     movd       m6, r4d
      pslld      m5, m6
      psrld      m5, 1
      punpcklbw  m4, m0
      packuswb   m0, m2
  %endmacro
  
- %macro BIWEIGHT_SSSE3_16 1
- cglobal h264_biweight_16x%1_ssse3, 7, 7, 8
+ INIT_XMM
+ cglobal h264_biweight_16_ssse3, 7, 7, 8
      BIWEIGHT_SSSE3_SETUP
-     mov        r3, %1
+     movifnidn r3d, r3m
  
- %if %1 == 16
  .nextrow
      movh       m0, [r0]
      movh       m2, [r0+8]
      mova       [r0], m0
      add        r0, r2
      add        r1, r2
-     dec        r3
+     dec        r3d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_biweight_16x16_ssse3.nextrow)
- %endif
- %endmacro
  
  INIT_XMM
- BIWEIGHT_SSSE3_16 16
- BIWEIGHT_SSSE3_16  8
- %macro BIWEIGHT_SSSE3_8 1
- cglobal h264_biweight_8x%1_ssse3, 7, 7, 8
+ cglobal h264_biweight_8_ssse3, 7, 7, 8
      BIWEIGHT_SSSE3_SETUP
-     mov        r3, %1/2
+     movifnidn r3d, r3m
+     sar        r3, 1
      lea        r4, [r2*2]
  
- %if %1 == 16
  .nextrow
      movh       m0, [r0]
      movh       m1, [r1]
      movhps     [r0+r2], m0
      add        r0, r4
      add        r1, r4
-     dec        r3
+     dec        r3d
      jnz .nextrow
      REP_RET
- %else
-     jmp mangle(ff_h264_biweight_8x16_ssse3.nextrow)
- %endif
- %endmacro
- INIT_XMM
- BIWEIGHT_SSSE3_8 16
- BIWEIGHT_SSSE3_8  8
- BIWEIGHT_SSSE3_8  4
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Copyright (c) 2004-2005 Michael Niedermayer, Loren Merritt
   *
 - * 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
   */
  
@@@ -298,63 -298,53 +298,53 @@@ LF_IFUNC(v,  luma_intra,      10, mmxex
  /***********************************/
  /* weighted prediction */
  
- #define H264_WEIGHT(W, H, OPT) \
- void ff_h264_weight_ ## W ## x ## H ## _ ## OPT(uint8_t *dst, \
-     int stride, int log2_denom, int weight, int offset);
+ #define H264_WEIGHT(W, OPT) \
+ void ff_h264_weight_ ## W ## _ ## OPT(uint8_t *dst, \
+     int stride, int height, int log2_denom, int weight, int offset);
  
- #define H264_BIWEIGHT(W, H, OPT) \
- void ff_h264_biweight_ ## W ## x ## H ## _ ## OPT(uint8_t *dst, \
-     uint8_t *src, int stride, int log2_denom, int weightd, \
+ #define H264_BIWEIGHT(W, OPT) \
+ void ff_h264_biweight_ ## W ## _ ## OPT(uint8_t *dst, \
+     uint8_t *src, int stride, int height, int log2_denom, int weightd, \
      int weights, int offset);
  
- #define H264_BIWEIGHT_MMX(W,H) \
- H264_WEIGHT  (W, H, mmx2) \
- H264_BIWEIGHT(W, H, mmx2)
- #define H264_BIWEIGHT_MMX_SSE(W,H) \
- H264_BIWEIGHT_MMX(W, H) \
- H264_WEIGHT      (W, H, sse2) \
- H264_BIWEIGHT    (W, H, sse2) \
- H264_BIWEIGHT    (W, H, ssse3)
- H264_BIWEIGHT_MMX_SSE(16, 16)
- H264_BIWEIGHT_MMX_SSE(16,  8)
- H264_BIWEIGHT_MMX_SSE( 8, 16)
- H264_BIWEIGHT_MMX_SSE( 8,  8)
- H264_BIWEIGHT_MMX_SSE( 8,  4)
- H264_BIWEIGHT_MMX    ( 4,  8)
- H264_BIWEIGHT_MMX    ( 4,  4)
- H264_BIWEIGHT_MMX    ( 4,  2)
- #define H264_WEIGHT_10(W, H, DEPTH, OPT) \
- void ff_h264_weight_ ## W ## x ## H ## _ ## DEPTH ## _ ## OPT(uint8_t *dst, \
-     int stride, int log2_denom, int weight, int offset);
- #define H264_BIWEIGHT_10(W, H, DEPTH, OPT) \
- void ff_h264_biweight_ ## W ## x ## H ## _ ## DEPTH ## _ ## OPT \
-     (uint8_t *dst, uint8_t *src, int stride, int log2_denom, \
+ #define H264_BIWEIGHT_MMX(W) \
+ H264_WEIGHT  (W, mmx2) \
+ H264_BIWEIGHT(W, mmx2)
+ #define H264_BIWEIGHT_MMX_SSE(W) \
+ H264_BIWEIGHT_MMX(W) \
+ H264_WEIGHT      (W, sse2) \
+ H264_BIWEIGHT    (W, sse2) \
+ H264_BIWEIGHT    (W, ssse3)
+ H264_BIWEIGHT_MMX_SSE(16)
+ H264_BIWEIGHT_MMX_SSE( 8)
+ H264_BIWEIGHT_MMX    ( 4)
+ #define H264_WEIGHT_10(W, DEPTH, OPT) \
+ void ff_h264_weight_ ## W ## _ ## DEPTH ## _ ## OPT(uint8_t *dst, \
+     int stride, int height, int log2_denom, int weight, int offset);
+ #define H264_BIWEIGHT_10(W, DEPTH, OPT) \
+ void ff_h264_biweight_ ## W ## _ ## DEPTH ## _ ## OPT \
+     (uint8_t *dst, uint8_t *src, int stride, int height, int log2_denom, \
       int weightd, int weights, int offset);
  
- #define H264_BIWEIGHT_10_SSE(W, H, DEPTH) \
- H264_WEIGHT_10  (W, H, DEPTH, sse2) \
- H264_WEIGHT_10  (W, H, DEPTH, sse4) \
- H264_BIWEIGHT_10(W, H, DEPTH, sse2) \
- H264_BIWEIGHT_10(W, H, DEPTH, sse4)
- H264_BIWEIGHT_10_SSE(16, 16, 10)
- H264_BIWEIGHT_10_SSE(16,  8, 10)
- H264_BIWEIGHT_10_SSE( 8, 16, 10)
- H264_BIWEIGHT_10_SSE( 8,  8, 10)
- H264_BIWEIGHT_10_SSE( 8,  4, 10)
- H264_BIWEIGHT_10_SSE( 4,  8, 10)
- H264_BIWEIGHT_10_SSE( 4,  4, 10)
- H264_BIWEIGHT_10_SSE( 4,  2, 10)
+ #define H264_BIWEIGHT_10_SSE(W, DEPTH) \
+ H264_WEIGHT_10  (W, DEPTH, sse2) \
+ H264_WEIGHT_10  (W, DEPTH, sse4) \
+ H264_BIWEIGHT_10(W, DEPTH, sse2) \
+ H264_BIWEIGHT_10(W, DEPTH, sse4)
+ H264_BIWEIGHT_10_SSE(16, 10)
+ H264_BIWEIGHT_10_SSE( 8, 10)
+ H264_BIWEIGHT_10_SSE( 4, 10)
  
  void ff_h264dsp_init_x86(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
  {
      int mm_flags = av_get_cpu_flags();
  
-     if (mm_flags & AV_CPU_FLAG_MMX2) {
+     if (chroma_format_idc == 1 && mm_flags & AV_CPU_FLAG_MMX2) {
          c->h264_loop_filter_strength= h264_loop_filter_strength_mmx2;
      }
  
              c->h264_v_loop_filter_luma_intra = ff_deblock_v_luma_intra_8_mmxext;
              c->h264_h_loop_filter_luma_intra = ff_deblock_h_luma_intra_8_mmxext;
  #endif
-             c->weight_h264_pixels_tab[0]= ff_h264_weight_16x16_mmx2;
-             c->weight_h264_pixels_tab[1]= ff_h264_weight_16x8_mmx2;
-             c->weight_h264_pixels_tab[2]= ff_h264_weight_8x16_mmx2;
-             c->weight_h264_pixels_tab[3]= ff_h264_weight_8x8_mmx2;
-             c->weight_h264_pixels_tab[4]= ff_h264_weight_8x4_mmx2;
-             c->weight_h264_pixels_tab[5]= ff_h264_weight_4x8_mmx2;
-             c->weight_h264_pixels_tab[6]= ff_h264_weight_4x4_mmx2;
-             c->weight_h264_pixels_tab[7]= ff_h264_weight_4x2_mmx2;
-             c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16x16_mmx2;
-             c->biweight_h264_pixels_tab[1]= ff_h264_biweight_16x8_mmx2;
-             c->biweight_h264_pixels_tab[2]= ff_h264_biweight_8x16_mmx2;
-             c->biweight_h264_pixels_tab[3]= ff_h264_biweight_8x8_mmx2;
-             c->biweight_h264_pixels_tab[4]= ff_h264_biweight_8x4_mmx2;
-             c->biweight_h264_pixels_tab[5]= ff_h264_biweight_4x8_mmx2;
-             c->biweight_h264_pixels_tab[6]= ff_h264_biweight_4x4_mmx2;
-             c->biweight_h264_pixels_tab[7]= ff_h264_biweight_4x2_mmx2;
+             c->weight_h264_pixels_tab[0]= ff_h264_weight_16_mmx2;
+             c->weight_h264_pixels_tab[1]= ff_h264_weight_8_mmx2;
+             c->weight_h264_pixels_tab[2]= ff_h264_weight_4_mmx2;
+             c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16_mmx2;
+             c->biweight_h264_pixels_tab[1]= ff_h264_biweight_8_mmx2;
+             c->biweight_h264_pixels_tab[2]= ff_h264_biweight_4_mmx2;
  
              if (mm_flags&AV_CPU_FLAG_SSE2) {
                  c->h264_idct8_add           = ff_h264_idct8_add_8_sse2;
                  c->h264_idct_add16intra     = ff_h264_idct_add16intra_8_sse2;
                  c->h264_luma_dc_dequant_idct= ff_h264_luma_dc_dequant_idct_sse2;
  
-                 c->weight_h264_pixels_tab[0]= ff_h264_weight_16x16_sse2;
-                 c->weight_h264_pixels_tab[1]= ff_h264_weight_16x8_sse2;
-                 c->weight_h264_pixels_tab[2]= ff_h264_weight_8x16_sse2;
-                 c->weight_h264_pixels_tab[3]= ff_h264_weight_8x8_sse2;
-                 c->weight_h264_pixels_tab[4]= ff_h264_weight_8x4_sse2;
+                 c->weight_h264_pixels_tab[0]= ff_h264_weight_16_sse2;
+                 c->weight_h264_pixels_tab[1]= ff_h264_weight_8_sse2;
  
-                 c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16x16_sse2;
-                 c->biweight_h264_pixels_tab[1]= ff_h264_biweight_16x8_sse2;
-                 c->biweight_h264_pixels_tab[2]= ff_h264_biweight_8x16_sse2;
-                 c->biweight_h264_pixels_tab[3]= ff_h264_biweight_8x8_sse2;
-                 c->biweight_h264_pixels_tab[4]= ff_h264_biweight_8x4_sse2;
+                 c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16_sse2;
+                 c->biweight_h264_pixels_tab[1]= ff_h264_biweight_8_sse2;
  
  #if HAVE_ALIGNED_STACK
                  c->h264_v_loop_filter_luma = ff_deblock_v_luma_8_sse2;
  #endif
              }
              if (mm_flags&AV_CPU_FLAG_SSSE3) {
-                 c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16x16_ssse3;
-                 c->biweight_h264_pixels_tab[1]= ff_h264_biweight_16x8_ssse3;
-                 c->biweight_h264_pixels_tab[2]= ff_h264_biweight_8x16_ssse3;
-                 c->biweight_h264_pixels_tab[3]= ff_h264_biweight_8x8_ssse3;
-                 c->biweight_h264_pixels_tab[4]= ff_h264_biweight_8x4_ssse3;
+                 c->biweight_h264_pixels_tab[0]= ff_h264_biweight_16_ssse3;
+                 c->biweight_h264_pixels_tab[1]= ff_h264_biweight_8_ssse3;
              }
 -            if (mm_flags&AV_CPU_FLAG_AVX) {
 +            if (HAVE_AVX && mm_flags&AV_CPU_FLAG_AVX) {
  #if HAVE_ALIGNED_STACK
                  c->h264_v_loop_filter_luma = ff_deblock_v_luma_8_avx;
                  c->h264_h_loop_filter_luma = ff_deblock_h_luma_8_avx;
                  c->h264_idct8_add4     = ff_h264_idct8_add4_10_sse2;
  #endif
  
-                 c->weight_h264_pixels_tab[0] = ff_h264_weight_16x16_10_sse2;
-                 c->weight_h264_pixels_tab[1] = ff_h264_weight_16x8_10_sse2;
-                 c->weight_h264_pixels_tab[2] = ff_h264_weight_8x16_10_sse2;
-                 c->weight_h264_pixels_tab[3] = ff_h264_weight_8x8_10_sse2;
-                 c->weight_h264_pixels_tab[4] = ff_h264_weight_8x4_10_sse2;
-                 c->weight_h264_pixels_tab[5] = ff_h264_weight_4x8_10_sse2;
-                 c->weight_h264_pixels_tab[6] = ff_h264_weight_4x4_10_sse2;
-                 c->weight_h264_pixels_tab[7] = ff_h264_weight_4x2_10_sse2;
-                 c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16x16_10_sse2;
-                 c->biweight_h264_pixels_tab[1] = ff_h264_biweight_16x8_10_sse2;
-                 c->biweight_h264_pixels_tab[2] = ff_h264_biweight_8x16_10_sse2;
-                 c->biweight_h264_pixels_tab[3] = ff_h264_biweight_8x8_10_sse2;
-                 c->biweight_h264_pixels_tab[4] = ff_h264_biweight_8x4_10_sse2;
-                 c->biweight_h264_pixels_tab[5] = ff_h264_biweight_4x8_10_sse2;
-                 c->biweight_h264_pixels_tab[6] = ff_h264_biweight_4x4_10_sse2;
-                 c->biweight_h264_pixels_tab[7] = ff_h264_biweight_4x2_10_sse2;
+                 c->weight_h264_pixels_tab[0] = ff_h264_weight_16_10_sse2;
+                 c->weight_h264_pixels_tab[1] = ff_h264_weight_8_10_sse2;
+                 c->weight_h264_pixels_tab[2] = ff_h264_weight_4_10_sse2;
+                 c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_10_sse2;
+                 c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_10_sse2;
+                 c->biweight_h264_pixels_tab[2] = ff_h264_biweight_4_10_sse2;
  
                  c->h264_v_loop_filter_chroma= ff_deblock_v_chroma_10_sse2;
                  c->h264_v_loop_filter_chroma_intra= ff_deblock_v_chroma_intra_10_sse2;
  #endif
              }
              if (mm_flags&AV_CPU_FLAG_SSE4) {
-                 c->weight_h264_pixels_tab[0] = ff_h264_weight_16x16_10_sse4;
-                 c->weight_h264_pixels_tab[1] = ff_h264_weight_16x8_10_sse4;
-                 c->weight_h264_pixels_tab[2] = ff_h264_weight_8x16_10_sse4;
-                 c->weight_h264_pixels_tab[3] = ff_h264_weight_8x8_10_sse4;
-                 c->weight_h264_pixels_tab[4] = ff_h264_weight_8x4_10_sse4;
-                 c->weight_h264_pixels_tab[5] = ff_h264_weight_4x8_10_sse4;
-                 c->weight_h264_pixels_tab[6] = ff_h264_weight_4x4_10_sse4;
-                 c->weight_h264_pixels_tab[7] = ff_h264_weight_4x2_10_sse4;
-                 c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16x16_10_sse4;
-                 c->biweight_h264_pixels_tab[1] = ff_h264_biweight_16x8_10_sse4;
-                 c->biweight_h264_pixels_tab[2] = ff_h264_biweight_8x16_10_sse4;
-                 c->biweight_h264_pixels_tab[3] = ff_h264_biweight_8x8_10_sse4;
-                 c->biweight_h264_pixels_tab[4] = ff_h264_biweight_8x4_10_sse4;
-                 c->biweight_h264_pixels_tab[5] = ff_h264_biweight_4x8_10_sse4;
-                 c->biweight_h264_pixels_tab[6] = ff_h264_biweight_4x4_10_sse4;
-                 c->biweight_h264_pixels_tab[7] = ff_h264_biweight_4x2_10_sse4;
+                 c->weight_h264_pixels_tab[0] = ff_h264_weight_16_10_sse4;
+                 c->weight_h264_pixels_tab[1] = ff_h264_weight_8_10_sse4;
+                 c->weight_h264_pixels_tab[2] = ff_h264_weight_4_10_sse4;
+                 c->biweight_h264_pixels_tab[0] = ff_h264_biweight_16_10_sse4;
+                 c->biweight_h264_pixels_tab[1] = ff_h264_biweight_8_10_sse4;
+                 c->biweight_h264_pixels_tab[2] = ff_h264_biweight_4_10_sse4;
              }
  #if HAVE_AVX
              if (mm_flags&AV_CPU_FLAG_AVX) {
diff --combined libavdevice/Makefile
@@@ -1,8 -1,5 +1,8 @@@
 +include $(SUBDIR)../config.mak
 +
  NAME    = avdevice
  FFLIBS  = avformat avcodec avutil
 +FFLIBS-$(CONFIG_LAVFI_INDEV) += avfilter
  
  HEADERS = avdevice.h
  
@@@ -10,21 -7,15 +10,21 @@@ OBJS    = alldevices.o avdevice.
  
  # input/output devices
  OBJS-$(CONFIG_ALSA_INDEV)                += alsa-audio-common.o \
--                                            alsa-audio-dec.o
++                                            alsa-audio-dec.o timefilter.o
  OBJS-$(CONFIG_ALSA_OUTDEV)               += alsa-audio-common.o \
                                              alsa-audio-enc.o
  OBJS-$(CONFIG_BKTR_INDEV)                += bktr.o
 +OBJS-$(CONFIG_DSHOW_INDEV)               += dshow.o dshow_enummediatypes.o \
 +                                            dshow_enumpins.o dshow_filter.o \
 +                                            dshow_pin.o dshow_common.o
  OBJS-$(CONFIG_DV1394_INDEV)              += dv1394.o
  OBJS-$(CONFIG_FBDEV_INDEV)               += fbdev.o
- OBJS-$(CONFIG_JACK_INDEV)                += jack_audio.o
+ OBJS-$(CONFIG_JACK_INDEV)                += jack_audio.o timefilter.o
 +OBJS-$(CONFIG_LAVFI_INDEV)               += lavfi.o
 +OBJS-$(CONFIG_OPENAL_INDEV)              += openal-dec.o
  OBJS-$(CONFIG_OSS_INDEV)                 += oss_audio.o
  OBJS-$(CONFIG_OSS_OUTDEV)                += oss_audio.o
 +OBJS-$(CONFIG_SDL_OUTDEV)                += sdl.o
  OBJS-$(CONFIG_SNDIO_INDEV)               += sndio_common.o sndio_dec.o
  OBJS-$(CONFIG_SNDIO_OUTDEV)              += sndio_common.o sndio_enc.o
  OBJS-$(CONFIG_V4L2_INDEV)                += v4l2.o
@@@ -39,4 -30,6 +39,6 @@@ OBJS-$(CONFIG_LIBDC1394_INDEV
  SKIPHEADERS-$(HAVE_ALSA_ASOUNDLIB_H)     += alsa-audio.h
  SKIPHEADERS-$(HAVE_SNDIO_H)              += sndio_common.h
  
+ TESTPROGS = timefilter
  include $(SRC_PATH)/subdir.mak
diff --combined libavdevice/alsa-audio.h
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2007 Luca Abeni ( lucabe72 email it )
   * Copyright (c) 2007 Benoit Fouet ( benoit fouet free fr )
   *
 - * 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 <alsa/asoundlib.h>
  #include "config.h"
 -#include "libavformat/avformat.h"
  #include "libavutil/log.h"
- #include "libavformat/timefilter.h"
++#include "timefilter.h"
 +#include "avdevice.h"
  
  /* XXX: we make the assumption that the soundcard accepts this format */
  /* XXX: find better solution with "preinit" method, needed also in
          other formats */
  #define DEFAULT_CODEC_ID AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE)
  
 -#define ALSA_BUFFER_SIZE_MAX 32768
 +typedef void (*ff_reorder_func)(const void *, void *, int);
 +
 +#define ALSA_BUFFER_SIZE_MAX 65536
  
  typedef struct {
      AVClass *class;
      snd_pcm_t *h;
 -    int frame_size;  ///< preferred size for reads and writes
 -    int period_size; ///< bytes per sample * channels
 +    int frame_size;  ///< bytes per sample * channels
 +    int period_size; ///< preferred size for reads and writes, in frames
      int sample_rate; ///< sample rate set by user
      int channels;    ///< number of channels set by user
 +    TimeFilter *timefilter;
      void (*reorder_func)(const void *, void *, int);
      void *reorder_buf;
      int reorder_buf_size; ///< in frames
diff --combined libavdevice/jack_audio.c
@@@ -3,20 -3,20 +3,20 @@@
   * Copyright (c) 2009 Samalyse
   * Author: Olivier Guilyardi <olivier samalyse com>
   *
 - * 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,8 -28,8 +28,9 @@@
  #include "libavutil/fifo.h"
  #include "libavutil/opt.h"
  #include "libavcodec/avcodec.h"
- #include "libavformat/timefilter.h"
+ #include "libavformat/avformat.h"
+ #include "timefilter.h"
 +#include "avdevice.h"
  
  /**
   * Size of the internal FIFO buffers as a number of audio packets
diff --combined libavdevice/timefilter.c
index 0000000,332d33b..3c67a59
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,151 +1,151 @@@
 - * This file is part of Libav.
+ /*
+  * Delay Locked Loop based time filter
+  * Copyright (c) 2009 Samalyse
+  * Copyright (c) 2009 Michael Niedermayer
+  * Author: Olivier Guilyardi <olivier samalyse com>
+  *         Michael Niedermayer <michaelni gmx at>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #include "config.h"
+ #include "timefilter.h"
+ #include "libavutil/mem.h"
+ struct TimeFilter {
+     /// Delay Locked Loop data. These variables refer to mathematical
+     /// concepts described in: http://www.kokkinizita.net/papers/usingdll.pdf
+     double cycle_time;
+     double feedback2_factor;
+     double feedback3_factor;
+     double clock_period;
+     int count;
+ };
+ TimeFilter * ff_timefilter_new(double clock_period, double feedback2_factor, double feedback3_factor)
+ {
+     TimeFilter *self        = av_mallocz(sizeof(TimeFilter));
+     self->clock_period      = clock_period;
+     self->feedback2_factor  = feedback2_factor;
+     self->feedback3_factor  = feedback3_factor;
+     return self;
+ }
+ void ff_timefilter_destroy(TimeFilter *self)
+ {
+     av_freep(&self);
+ }
+ void ff_timefilter_reset(TimeFilter *self)
+ {
+     self->count      = 0;
+ }
+ double ff_timefilter_update(TimeFilter *self, double system_time, double period)
+ {
+     self->count++;
+     if (self->count==1) {
+         /// init loop
+         self->cycle_time    = system_time;
+     } else {
+         double loop_error;
+         self->cycle_time   += self->clock_period * period;
+         /// calculate loop error
+         loop_error          = system_time - self->cycle_time;
+         /// update loop
+         self->cycle_time   += FFMAX(self->feedback2_factor, 1.0/(self->count)) * loop_error;
+         self->clock_period += self->feedback3_factor * loop_error / period;
+     }
+     return self->cycle_time;
+ }
+ #ifdef TEST
+ #include "libavutil/lfg.h"
+ #define LFG_MAX ((1LL << 32) - 1)
+ #undef printf
+ int main(void)
+ {
+     AVLFG prng;
+     double n0,n1;
+ #define SAMPLES 1000
+     double ideal[SAMPLES];
+     double samples[SAMPLES];
+ #if 1
+     for(n0= 0; n0<40; n0=2*n0+1){
+         for(n1= 0; n1<10; n1=2*n1+1){
+ #else
+     {{
+         n0=7;
+         n1=1;
+ #endif
+             double best_error= 1000000000;
+             double bestpar0=1;
+             double bestpar1=0.001;
+             int better, i;
+             av_lfg_init(&prng, 123);
+             for(i=0; i<SAMPLES; i++){
+                 ideal[i]  = 10 + i + n1*i/(1000);
+                 samples[i] = ideal[i] + n0 * (av_lfg_get(&prng) - LFG_MAX / 2)
+                                            / (LFG_MAX * 10LL);
+             }
+             do{
+                 double par0, par1;
+                 better=0;
+                 for(par0= bestpar0*0.8; par0<=bestpar0*1.21; par0+=bestpar0*0.05){
+                     for(par1= bestpar1*0.8; par1<=bestpar1*1.21; par1+=bestpar1*0.05){
+                         double error=0;
+                         TimeFilter *tf= ff_timefilter_new(1, par0, par1);
+                         for(i=0; i<SAMPLES; i++){
+                             double filtered;
+                             filtered=  ff_timefilter_update(tf, samples[i], 1);
+                             error += (filtered - ideal[i]) * (filtered - ideal[i]);
+                         }
+                         ff_timefilter_destroy(tf);
+                         if(error < best_error){
+                             best_error= error;
+                             bestpar0= par0;
+                             bestpar1= par1;
+                             better=1;
+                         }
+                     }
+                 }
+             }while(better);
+ #if 0
+             double lastfil=9;
+             TimeFilter *tf= ff_timefilter_new(1, bestpar0, bestpar1);
+             for(i=0; i<SAMPLES; i++){
+                 double filtered;
+                 filtered=  ff_timefilter_update(tf, samples[i], 1);
+                 printf("%f %f %f %f\n", i - samples[i] + 10, filtered - samples[i], samples[FFMAX(i, 1)] - samples[FFMAX(i-1, 0)], filtered - lastfil);
+                 lastfil= filtered;
+             }
+             ff_timefilter_destroy(tf);
+ #else
+             printf(" [%f %f %9f]", bestpar0, bestpar1, best_error);
+ #endif
+         }
+         printf("\n");
+     }
+     return 0;
+ }
+ #endif
diff --combined libavdevice/timefilter.h
index 0000000,c98fd03..4580904
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,97 +1,97 @@@
 - * This file is part of Libav.
+ /*
+  * Delay Locked Loop based time filter prototypes and declarations
+  * Copyright (c) 2009 Samalyse
+  * Copyright (c) 2009 Michael Niedermayer
+  * Author: Olivier Guilyardi <olivier samalyse com>
+  *         Michael Niedermayer <michaelni gmx at>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVDEVICE_TIMEFILTER_H
+ #define AVDEVICE_TIMEFILTER_H
+ /**
+  * Opaque type representing a time filter state
+  *
+  * The purpose of this filter is to provide a way to compute accurate time
+  * stamps that can be compared to wall clock time, especially when dealing
+  * with two clocks: the system clock and a hardware device clock, such as
+  * a soundcard.
+  */
+ typedef struct TimeFilter TimeFilter;
+ /**
+  * Create a new Delay Locked Loop time filter
+  *
+  * feedback2_factor and feedback3_factor are the factors used for the
+  * multiplications that are respectively performed in the second and third
+  * feedback paths of the loop.
+  *
+  * Unless you know what you are doing, you should set these as follow:
+  *
+  * o = 2 * M_PI * bandwidth * period
+  * feedback2_factor = sqrt(2 * o)
+  * feedback3_factor = o * o
+  *
+  * Where bandwidth is up to you to choose. Smaller values will filter out more
+  * of the jitter, but also take a longer time for the loop to settle. A good
+  * starting point is something between 0.3 and 3 Hz.
+  *
+  * @param clock_period period of the hardware clock in seconds
+  *        (for example 1.0/44100)
+  *
+  * For more details about these parameters and background concepts please see:
+  * http://www.kokkinizita.net/papers/usingdll.pdf
+  */
+ TimeFilter * ff_timefilter_new(double clock_period, double feedback2_factor, double feedback3_factor);
+ /**
+  * Update the filter
+  *
+  * This function must be called in real time, at each process cycle.
+  *
+  * @param period the device cycle duration in clock_periods. For example, at
+  * 44.1kHz and a buffer size of 512 frames, period = 512 when clock_period
+  * was 1.0/44100, or 512/44100 if clock_period was 1.
+  *
+  * system_time, in seconds, should be the value of the system clock time,
+  * at (or as close as possible to) the moment the device hardware interrupt
+  * occured (or any other event the device clock raises at the beginning of a
+  * cycle).
+  *
+  * @return the filtered time, in seconds
+  */
+ double ff_timefilter_update(TimeFilter *self, double system_time, double period);
+ /**
+  * Reset the filter
+  *
+  * This function should mainly be called in case of XRUN.
+  *
+  * Warning: after calling this, the filter is in an undetermined state until
+  * the next call to ff_timefilter_update()
+  */
+ void ff_timefilter_reset(TimeFilter *);
+ /**
+  * Free all resources associated with the filter
+  */
+ void ff_timefilter_destroy(TimeFilter *);
+ #endif /* AVDEVICE_TIMEFILTER_H */
diff --combined libavformat/Makefile
@@@ -1,5 -1,3 +1,5 @@@
 +include $(SUBDIR)../config.mak
 +
  NAME = avformat
  FFLIBS = avcodec avutil
  
@@@ -21,12 -19,10 +21,12 @@@ OBJS-$(CONFIG_A64_MUXER
  OBJS-$(CONFIG_AAC_DEMUXER)               += aacdec.o rawdec.o
  OBJS-$(CONFIG_AC3_DEMUXER)               += ac3dec.o rawdec.o
  OBJS-$(CONFIG_AC3_MUXER)                 += rawenc.o
 +OBJS-$(CONFIG_ACT_DEMUXER)               += act.o
 +OBJS-$(CONFIG_ADF_DEMUXER)               += bintext.o sauce.o
  OBJS-$(CONFIG_ADTS_MUXER)                += adtsenc.o
  OBJS-$(CONFIG_AEA_DEMUXER)               += aea.o pcm.o
 -OBJS-$(CONFIG_AIFF_DEMUXER)              += aiffdec.o riff.o pcm.o
 -OBJS-$(CONFIG_AIFF_MUXER)                += aiffenc.o riff.o
 +OBJS-$(CONFIG_AIFF_DEMUXER)              += aiffdec.o riff.o pcm.o isom.o
 +OBJS-$(CONFIG_AIFF_MUXER)                += aiffenc.o riff.o isom.o
  OBJS-$(CONFIG_AMR_DEMUXER)               += amr.o
  OBJS-$(CONFIG_AMR_MUXER)                 += amr.o
  OBJS-$(CONFIG_ANM_DEMUXER)               += anm.o
@@@ -48,12 -44,8 +48,12 @@@ OBJS-$(CONFIG_AVS_DEMUXER
  OBJS-$(CONFIG_BETHSOFTVID_DEMUXER)       += bethsoftvid.o
  OBJS-$(CONFIG_BFI_DEMUXER)               += bfi.o
  OBJS-$(CONFIG_BINK_DEMUXER)              += bink.o
 +OBJS-$(CONFIG_BINTEXT_DEMUXER)           += bintext.o sauce.o
 +OBJS-$(CONFIG_BIT_DEMUXER)               += bit.o
 +OBJS-$(CONFIG_BIT_MUXER)                 += bit.o
  OBJS-$(CONFIG_C93_DEMUXER)               += c93.o vocdec.o voc.o
  OBJS-$(CONFIG_CAF_DEMUXER)               += cafdec.o caf.o mov.o riff.o isom.o
 +OBJS-$(CONFIG_CAF_MUXER)                 += cafenc.o caf.o riff.o isom.o
  OBJS-$(CONFIG_CAVSVIDEO_DEMUXER)         += cavsvideodec.o rawdec.o
  OBJS-$(CONFIG_CAVSVIDEO_MUXER)           += rawenc.o
  OBJS-$(CONFIG_CDG_DEMUXER)               += cdg.o
@@@ -98,8 -90,6 +98,8 @@@ OBJS-$(CONFIG_GXF_DEMUXER
  OBJS-$(CONFIG_GXF_MUXER)                 += gxfenc.o audiointerleave.o
  OBJS-$(CONFIG_G722_DEMUXER)              += rawdec.o
  OBJS-$(CONFIG_G722_MUXER)                += rawenc.o
 +OBJS-$(CONFIG_G723_1_DEMUXER)            += g723_1.o
 +OBJS-$(CONFIG_G723_1_MUXER)              += rawenc.o
  OBJS-$(CONFIG_H261_DEMUXER)              += h261dec.o rawdec.o
  OBJS-$(CONFIG_H261_MUXER)                += rawenc.o
  OBJS-$(CONFIG_H263_DEMUXER)              += h263dec.o rawdec.o
@@@ -107,7 -97,6 +107,7 @@@ OBJS-$(CONFIG_H263_MUXER
  OBJS-$(CONFIG_H264_DEMUXER)              += h264dec.o rawdec.o
  OBJS-$(CONFIG_H264_MUXER)                += rawenc.o
  OBJS-$(CONFIG_IDCIN_DEMUXER)             += idcin.o
 +OBJS-$(CONFIG_IDF_DEMUXER)               += bintext.o
  OBJS-$(CONFIG_IFF_DEMUXER)               += iff.o
  OBJS-$(CONFIG_IMAGE2_DEMUXER)            += img2.o
  OBJS-$(CONFIG_IMAGE2_MUXER)              += img2.o
@@@