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 --cc Changelog
+++ b/Changelog
@@@ -43,36 -41,48 +43,37 @@@ easier to use. The changes are
        '-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
@@@ -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;
Simple merge
Simple merge
@@@ -1884,11 -1911,16 +1947,11 @@@ static av_always_inline void hl_decode_
              }
              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);
                      }
                  }
              }
@@@ -2704,11 -2727,7 +2785,11 @@@ static int decode_slice_header(H264Cont
              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,
Simple merge
Simple merge
Simple merge
Simple merge
  
  #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; \
@@@ -62,10 -66,10 +66,10 @@@ static void FUNCC(biweight_h264_pixels 
      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; \
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -442,13 -416,10 +416,10 @@@ void ff_h264dsp_init_x86(H264DSPContex
  #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;
@@@ -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
@@@ -32,9 -32,8 +32,9 @@@
  
  #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
@@@ -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
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
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 */
@@@ -354,11 -334,8 +354,8 @@@ OBJS-$(CONFIG_RTP_PROTOCOL
  OBJS-$(CONFIG_TCP_PROTOCOL)              += tcp.o
  OBJS-$(CONFIG_UDP_PROTOCOL)              += udp.o
  
- # libavdevice dependencies
- OBJS-$(CONFIG_ALSA_INDEV)                += timefilter.o
- OBJS-$(CONFIG_JACK_INDEV)                += timefilter.o
 -EXAMPLES  = metadata output
 +
- TESTPROGS = seek timefilter
+ TESTPROGS = seek
  TOOLS     = pktdumper probetest
  
  include $(SRC_PATH)/subdir.mak
@@@ -228,9 -239,10 +228,10 @@@ static int amf_parse_object(AVFormatCon
          case AMF_DATA_TYPE_OBJECT: {
              unsigned int keylen;
  
-             if (vstream && ioc->seekable && key && !strcmp(KEYFRAMES_TAG, key) && depth == 1)
-                 if (parse_keyframes_index(s, ioc, vstream, max_pos) < 0)
 -            if ((vstream || astream) && key && !strcmp(KEYFRAMES_TAG, key) && depth == 1)
++            if ((vstream || astream) && ioc->seekable && key && !strcmp(KEYFRAMES_TAG, key) && depth == 1)
+                 if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,
+                                           max_pos) < 0)
 -                    return -1;
 +                    av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
  
              while(avio_tell(ioc) < max_pos - 2 && (keylen = avio_rb16(ioc))) {
                  avio_skip(ioc, keylen); //skip key string
@@@ -361,9 -350,10 +369,10 @@@ static int flv_write_trailer(AVFormatCo
      /* Add EOS tag */
      for (i = 0; i < s->nb_streams; i++) {
          AVCodecContext *enc = s->streams[i]->codec;
+         FLVStreamContext *sc = s->streams[i]->priv_data;
          if (enc->codec_type == AVMEDIA_TYPE_VIDEO &&
 -                enc->codec_id == CODEC_ID_H264) {
 +                (enc->codec_id == CODEC_ID_H264 || enc->codec_id == CODEC_ID_MPEG4)) {
-             put_avc_eos_tag(pb, flv->last_ts);
+             put_avc_eos_tag(pb, sc->last_ts);
          }
      }
  
@@@ -429,18 -415,14 +439,18 @@@ static int flv_write_packet(AVFormatCon
              if (ff_avc_parse_nal_units_buf(pkt->data, &data, &size) < 0)
                  return -1;
          }
 +    } else if (enc->codec_id == CODEC_ID_AAC && pkt->size > 2 &&
 +               (AV_RB16(pkt->data) & 0xfff0) == 0xfff0) {
 +        av_log(s, AV_LOG_ERROR, "malformated aac bitstream, use -absf aac_adtstoasc\n");
 +        return -1;
      }
-     if (!flv->delay && pkt->dts < 0)
-         flv->delay = -pkt->dts;
+     if (!sc->delay && pkt->dts < 0)
+         sc->delay = -pkt->dts;
  
-     ts = pkt->dts + flv->delay; // add delay to force positive dts
+     ts = pkt->dts + sc->delay; // add delay to force positive dts
  
      /* check Speex packet duration */
-     if (enc->codec_id == CODEC_ID_SPEEX && ts - flv->last_ts > 160) {
+     if (enc->codec_id == CODEC_ID_SPEEX && ts - sc->last_ts > 160) {
          av_log(s, AV_LOG_WARNING, "Warning: Speex stream has more than "
                                    "8 frames per packet. Adobe Flash "
                                    "Player cannot handle this!\n");
Simple merge
Simple merge
@@@ -149,12 -145,8 +149,15 @@@ enum PixelFormat 
      PIX_FMT_YUV444P9LE, ///< planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
      PIX_FMT_YUV444P10BE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
      PIX_FMT_YUV444P10LE,///< planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
+     PIX_FMT_YUV422P9BE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
+     PIX_FMT_YUV422P9LE, ///< planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
 +
 +    PIX_FMT_RGBA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
 +    PIX_FMT_RGBA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
 +    PIX_FMT_BGRA64BE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as big-endian
 +    PIX_FMT_BGRA64LE,  ///< packed RGBA 16:16:16:16, 64bpp, 16B, 16G, 16R, 16A, the 2-byte value for each R/G/B/A component is stored as little-endian
 +    PIX_FMT_GBR24P,    ///< planar GBR, 24bpp, 8G, 8B, 8R.
++
      PIX_FMT_NB,        ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
  };
  
Simple merge
@@@ -2843,10 -2662,11 +2843,11 @@@ static av_cold void sws_init_swScale_c(
          case PIX_FMT_RGB4_BYTE: c->chrToYV12 = palToUV_c; break;
  #if HAVE_BIGENDIAN
          case PIX_FMT_YUV444P9LE:
+         case PIX_FMT_YUV422P9LE:
          case PIX_FMT_YUV420P9LE:
          case PIX_FMT_YUV422P10LE:
 -        case PIX_FMT_YUV444P10LE:
          case PIX_FMT_YUV420P10LE:
 +        case PIX_FMT_YUV444P10LE:
          case PIX_FMT_YUV420P16LE:
          case PIX_FMT_YUV422P16LE:
          case PIX_FMT_YUV444P16LE: c->chrToYV12 = bswap16UV_c; break;
      switch (srcFormat) {
  #if HAVE_BIGENDIAN
      case PIX_FMT_YUV444P9LE:
+     case PIX_FMT_YUV422P9LE:
      case PIX_FMT_YUV420P9LE:
 -    case PIX_FMT_YUV444P10LE:
      case PIX_FMT_YUV422P10LE:
      case PIX_FMT_YUV420P10LE:
 +    case PIX_FMT_YUV444P10LE:
      case PIX_FMT_YUV420P16LE:
      case PIX_FMT_YUV422P16LE:
      case PIX_FMT_YUV444P16LE:
@@@ -544,9 -532,11 +544,11 @@@ const char *sws_format_name(enum PixelF
          || (x)==PIX_FMT_YUV422P16BE \
          || (x)==PIX_FMT_YUV444P16BE \
      )
 -#define is9_OR_10BPS(x) (           \
 +#define isNBPS(x)       (           \
             (x)==PIX_FMT_YUV420P9LE  \
          || (x)==PIX_FMT_YUV420P9BE  \
+         || (x)==PIX_FMT_YUV422P9LE  \
+         || (x)==PIX_FMT_YUV422P9BE  \
          || (x)==PIX_FMT_YUV444P9BE  \
          || (x)==PIX_FMT_YUV444P9LE  \
          || (x)==PIX_FMT_YUV422P10BE \
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge