Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 28 Jan 2012 03:23:26 +0000 (04:23 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 28 Jan 2012 06:53:34 +0000 (07:53 +0100)
* qatar/master: (71 commits)
  movenc: Allow writing to a non-seekable output if using empty moov
  movenc: Support adding isml (smooth streaming live) metadata
  libavcodec: Don't crash in avcodec_encode_audio if time_base isn't set
  sunrast: Document the different Sun Raster file format types.
  sunrast: Add a check for experimental type.
  libspeexenc: use AVSampleFormat instead of deprecated/removed SampleFormat
  lavf: remove disabled FF_API_SET_PTS_INFO cruft
  lavf: remove disabled FF_API_OLD_INTERRUPT_CB cruft
  lavf: remove disabled FF_API_REORDER_PRIVATE cruft
  lavf: remove disabled FF_API_SEEK_PUBLIC cruft
  lavf: remove disabled FF_API_STREAM_COPY cruft
  lavf: remove disabled FF_API_PRELOAD cruft
  lavf: remove disabled FF_API_NEW_STREAM cruft
  lavf: remove disabled FF_API_RTSP_URL_OPTIONS cruft
  lavf: remove disabled FF_API_MUXRATE cruft
  lavf: remove disabled FF_API_FILESIZE cruft
  lavf: remove disabled FF_API_TIMESTAMP cruft
  lavf: remove disabled FF_API_LOOP_OUTPUT cruft
  lavf: remove disabled FF_API_LOOP_INPUT cruft
  lavf: remove disabled FF_API_AVSTREAM_QUALITY cruft
  ...

Conflicts:
doc/APIchanges
libavcodec/8bps.c
libavcodec/avcodec.h
libavcodec/libx264.c
libavcodec/mjpegbdec.c
libavcodec/options.c
libavcodec/sunrast.c
libavcodec/utils.c
libavcodec/version.h
libavcodec/x86/h264_deblock.asm
libavdevice/libdc1394.c
libavdevice/v4l2.c
libavformat/avformat.h
libavformat/avio.c
libavformat/avio.h
libavformat/aviobuf.c
libavformat/dv.c
libavformat/mov.c
libavformat/utils.c
libavformat/version.h
libavformat/wtv.c
libavutil/Makefile
libavutil/file.c
libswscale/x86/input.asm
libswscale/x86/swscale_mmx.c
libswscale/x86/swscale_template.c
tests/ref/lavf/ffm

Merged-by: Michael Niedermayer <michaelni@gmx.at>
220 files changed:
1  2 
cmdutils.c
configure
doc/APIchanges
ffmpeg.c
ffplay.c
libavcodec/8bps.c
libavcodec/Makefile
libavcodec/ac3dec.c
libavcodec/audioconvert.c
libavcodec/audioconvert.h
libavcodec/avcodec.h
libavcodec/flacenc.c
libavcodec/frwu.c
libavcodec/g723_1.c
libavcodec/h264.c
libavcodec/imgconvert.c
libavcodec/libaacplus.c
libavcodec/libmp3lame.c
libavcodec/libspeexenc.c
libavcodec/libx264.c
libavcodec/libxavs.c
libavcodec/mjpegbdec.c
libavcodec/mjpegdec.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videodec.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodec_float.c
libavcodec/mpegvideo_enc.c
libavcodec/options.c
libavcodec/sunrast.c
libavcodec/tiffenc.c
libavcodec/utils.c
libavcodec/vc1dec.c
libavcodec/version.h
libavcodec/x86/ac3dsp.asm
libavcodec/x86/dct32_sse.asm
libavcodec/x86/diracdsp_yasm.asm
libavcodec/x86/dsputil_yasm.asm
libavcodec/x86/dsputilenc_yasm.asm
libavcodec/x86/fft_mmx.asm
libavcodec/x86/fmtconvert.asm
libavcodec/x86/h264_chromamc.asm
libavcodec/x86/h264_deblock.asm
libavcodec/x86/h264_deblock_10bit.asm
libavcodec/x86/h264_idct.asm
libavcodec/x86/h264_idct_10bit.asm
libavcodec/x86/h264_intrapred.asm
libavcodec/x86/h264_intrapred_10bit.asm
libavcodec/x86/h264_weight.asm
libavcodec/x86/imdct36_sse.asm
libavcodec/x86/proresdsp.asm
libavcodec/x86/vp3dsp.asm
libavcodec/x86/vp56dsp.asm
libavdevice/alsa-audio-dec.c
libavdevice/bktr.c
libavdevice/dshow.c
libavdevice/dv1394.c
libavdevice/fbdev.c
libavdevice/jack_audio.c
libavdevice/lavfi.c
libavdevice/libcdio.c
libavdevice/libdc1394.c
libavdevice/openal-dec.c
libavdevice/oss_audio.c
libavdevice/pulse.c
libavdevice/sndio_dec.c
libavdevice/v4l2.c
libavdevice/vfwcap.c
libavdevice/x11grab.c
libavfilter/libmpcodecs/mp_image.h
libavformat/4xm.c
libavformat/aacdec.c
libavformat/act.c
libavformat/aea.c
libavformat/aiffdec.c
libavformat/amr.c
libavformat/anm.c
libavformat/apc.c
libavformat/ape.c
libavformat/applehttp.c
libavformat/asfdec.c
libavformat/assdec.c
libavformat/au.c
libavformat/avformat.h
libavformat/avidec.c
libavformat/avio.c
libavformat/avio.h
libavformat/aviobuf.c
libavformat/avisynth.c
libavformat/avs.c
libavformat/bethsoftvid.c
libavformat/bfi.c
libavformat/bink.c
libavformat/bintext.c
libavformat/bit.c
libavformat/c93.c
libavformat/cafdec.c
libavformat/cdg.c
libavformat/daud.c
libavformat/dfa.c
libavformat/dsicin.c
libavformat/dv.c
libavformat/dvenc.c
libavformat/dxa.c
libavformat/eacdata.c
libavformat/electronicarts.c
libavformat/ffmdec.c
libavformat/ffmenc.c
libavformat/ffmetadec.c
libavformat/filmstripdec.c
libavformat/flacdec.c
libavformat/flic.c
libavformat/flvdec.c
libavformat/g723_1.c
libavformat/g729dec.c
libavformat/gif.c
libavformat/gxf.c
libavformat/gxfenc.c
libavformat/icodec.c
libavformat/idcin.c
libavformat/idroqdec.c
libavformat/iff.c
libavformat/img2.c
libavformat/ipmovie.c
libavformat/iss.c
libavformat/iv8.c
libavformat/ivfdec.c
libavformat/jvdec.c
libavformat/libmodplug.c
libavformat/libnut.c
libavformat/lmlm4.c
libavformat/loasdec.c
libavformat/lxfdec.c
libavformat/matroskadec.c
libavformat/metadata.c
libavformat/metadata.h
libavformat/microdvddec.c
libavformat/mkvtimestamp_v2.c
libavformat/mm.c
libavformat/mmf.c
libavformat/mov.c
libavformat/movenc.c
libavformat/movenc.h
libavformat/mp3dec.c
libavformat/mpc.c
libavformat/mpc8.c
libavformat/mpeg.c
libavformat/mpegenc.c
libavformat/mpegts.c
libavformat/mpegtsenc.c
libavformat/msnwc_tcp.c
libavformat/mtv.c
libavformat/mvi.c
libavformat/mxfdec.c
libavformat/mxfenc.c
libavformat/mxg.c
libavformat/ncdec.c
libavformat/nsvdec.c
libavformat/nutdec.c
libavformat/nuv.c
libavformat/oggdec.c
libavformat/omadec.c
libavformat/options.c
libavformat/pmpdec.c
libavformat/psxstr.c
libavformat/pva.c
libavformat/qcp.c
libavformat/r3d.c
libavformat/rawdec.c
libavformat/rawdec.h
libavformat/rl2.c
libavformat/rmdec.c
libavformat/rpl.c
libavformat/rsodec.c
libavformat/rtsp.c
libavformat/rtspdec.c
libavformat/sapdec.c
libavformat/sbgdec.c
libavformat/sdp.c
libavformat/segafilm.c
libavformat/sierravmd.c
libavformat/siff.c
libavformat/smacker.c
libavformat/sol.c
libavformat/soxdec.c
libavformat/spdifdec.c
libavformat/srtdec.c
libavformat/swfdec.c
libavformat/thp.c
libavformat/tiertexseq.c
libavformat/tmv.c
libavformat/tta.c
libavformat/tty.c
libavformat/txd.c
libavformat/url.h
libavformat/utils.c
libavformat/vc1test.c
libavformat/version.h
libavformat/vocdec.c
libavformat/vqf.c
libavformat/wav.c
libavformat/wc3movie.c
libavformat/westwood_vqa.c
libavformat/wtvdec.c
libavformat/wv.c
libavformat/xa.c
libavformat/xmv.c
libavformat/xwma.c
libavformat/yop.c
libavformat/yuv4mpeg.c
libavutil/file.c
libavutil/x86/x86inc.asm
libavutil/x86/x86util.asm
libswscale/x86/input.asm
libswscale/x86/output.asm
libswscale/x86/scale.asm
libswscale/x86/swscale_mmx.c
libswscale/x86/swscale_template.c
tests/codec-regression.sh
tests/lavf-regression.sh

diff --cc cmdutils.c
@@@ -847,34 -720,25 +845,29 @@@ int opt_bsfs(const char *opt, const cha
      while ((bsf = av_bitstream_filter_next(bsf)))
          printf("%s\n", bsf->name);
      printf("\n");
 +    return 0;
  }
  
 -void show_protocols(void)
 +int opt_protocols(const char *opt, const char *arg)
  {
-     URLProtocol *up=NULL;
+     void *opaque = NULL;
+     const char *name;
  
      printf("Supported file protocols:\n"
-            "I.. = Input  supported\n"
-            ".O. = Output supported\n"
-            "..S = Seek   supported\n"
-            "FLAGS NAME\n"
-            "----- \n");
-     while((up = av_protocol_next(up)))
-         printf("%c%c%c   %s\n",
-                up->url_read  ? 'I' : '.',
-                up->url_write ? 'O' : '.',
-                up->url_seek  ? 'S' : '.',
-                up->name);
-     return 0;
+            "Input:\n");
+     while ((name = avio_enum_protocols(&opaque, 0)))
+         printf("%s\n", name);
+     printf("Output:\n");
+     while ((name = avio_enum_protocols(&opaque, 1)))
+         printf("%s\n", name);
  }
  
 -void show_filters(void)
 +int opt_filters(const char *opt, const char *arg)
  {
      AVFilter av_unused(**filter) = NULL;
 +    char descr[64], *descr_cur;
 +    int i, j;
 +    const AVFilterPad *pad;
  
      printf("Filters:\n");
  #if CONFIG_AVFILTER
diff --cc configure
+++ b/configure
@@@ -1188,8 -1092,9 +1189,10 @@@ HAVE_LIST=
      inet_aton
      inline_asm
      isatty
 +    kbhit
      ldbrx
+     libdc1394_1
+     libdc1394_2
      llrint
      llrintf
      local_aligned_16
@@@ -3125,12 -2934,6 +3128,11 @@@ check_mathfunc trunc
  enabled avisynth   && require2 vfw32 "windows.h vfw.h" AVIFileInit -lavifil32
  enabled frei0r     && { check_header frei0r.h || die "ERROR: frei0r.h header not found"; }
  enabled gnutls     && require_pkg_config gnutls gnutls/gnutls.h gnutls_global_init
- enabled libdc1394  && require_pkg_config libdc1394-2 dc1394/dc1394.h dc1394_new
 +enabled libaacplus && require  "libaacplus >= 2.0.0" aacplus.h aacplusEncOpen -laacplus
 +enabled libass     && require_pkg_config libass ass/ass.h ass_library_init
 +enabled libcelt    && require libcelt celt/celt.h celt_decode -lcelt0 &&
 +                      { check_lib celt/celt.h celt_decoder_create_custom -lcelt0 ||
 +                        die "ERROR: libcelt version must be >= 0.11.0."; }
  enabled libdirac   && require_pkg_config dirac                          \
      "libdirac_decoder/dirac_parser.h libdirac_encoder/dirac_encoder.h"  \
      "dirac_decoder_init dirac_encoder_init"
@@@ -3178,7 -2970,15 +3180,16 @@@ enabled openssl    && { check_lib opens
                          check_lib openssl/ssl.h SSL_library_init -lssl -lcrypto -lws2_32 -lgdi32 ||
                          die "ERROR: openssl not found"; }
  
+ # libdc1394 check
+ if enabled libdc1394; then
+     { check_lib dc1394/dc1394.h dc1394_new -ldc1394 -lraw1394 &&
+         enable libdc1394_2; } ||
+     { check_lib libdc1394/dc1394_control.h dc1394_create_handle -ldc1394_control -lraw1394 &&
+         enable libdc1394_1; } ||
+     die "ERROR: No version of libdc1394 found "
+ fi
 +SDL_CONFIG="${cross_prefix}sdl-config"
  if check_pkg_config sdl SDL_version.h SDL_Linked_Version; then
      check_cpp_condition SDL.h "(SDL_MAJOR_VERSION<<16 | SDL_MINOR_VERSION<<8 | SDL_PATCHLEVEL) >= 0x010201" $sdl_cflags &&
      enable sdl &&
diff --cc doc/APIchanges
@@@ -2,11 -2,11 +2,11 @@@ Never assume the API of libav* to be st
  since the last major version increase.
  
  The last version increases were:
- libavcodec:  2011-04-18
+ libavcodec:  2012-01-27
  libavdevice: 2011-04-18
  libavfilter: 2011-04-18
- libavformat: 2011-04-18
+ libavformat: 2012-01-27
 -libpostproc: 2011-04-18 (deprecated, to be removed later)
 +libpostproc: 2011-04-18
  libswscale:  2011-06-20
  libavutil:   2011-04-18
  
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -133,16 -108,9 +133,14 @@@ static int video_discard = 0
  static int same_quant = 0;
  static int do_deinterlace = 0;
  static int intra_dc_precision = 8;
- static int loop_input = 0;
- static int loop_output = AVFMT_NOOUTPUTLOOP;
  static int qp_hist = 0;
 +static int intra_only = 0;
 +static const char *video_codec_name    = NULL;
 +static const char *audio_codec_name    = NULL;
 +static const char *subtitle_codec_name = NULL;
  
  static int file_overwrite = 0;
 +static int no_file_overwrite = 0;
  static int do_benchmark = 0;
  static int do_hex_dump = 0;
  static int do_pkt_dump = 0;
@@@ -3690,15 -3287,7 +3688,7 @@@ static int opt_input_file(OptionsContex
      ic->flags |= AVFMT_FLAG_NONBLOCK;
      ic->interrupt_callback = int_cb;
  
-     if (loop_input) {
-         av_log(NULL, AV_LOG_WARNING,
-             "-loop_input is deprecated, use -loop 1\n"
-             "Note, both loop options only work with -f image2\n"
-         );
-         ic->loop_input = loop_input;
-     }
 -    /* open the input file with generic libav function */
 +    /* open the input file with generic avformat function */
      err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
      if (err < 0) {
          print_error(filename, err);
@@@ -4477,12 -3985,8 +4467,7 @@@ static void opt_output_file(void *optct
          av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
      }
      oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
 -    oc->flags |= AVFMT_FLAG_NONBLOCK;
  
-     if (loop_output >= 0) {
-         av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
-         oc->loop_output = loop_output;
-     }
      /* copy metadata */
      for (i = 0; i < o->nb_metadata_map; i++) {
          char *p;
diff --cc ffplay.c
+++ b/ffplay.c
@@@ -1545,7 -1527,7 +1545,7 @@@ static int input_get_buffer(AVCodecCont
      AVFilterContext *ctx = codec->opaque;
      AVFilterBufferRef  *ref;
      int perms = AV_PERM_WRITE;
--    int i, w, h, stride[4];
++    int i, w, h, stride[AV_NUM_DATA_POINTERS];
      unsigned edge;
      int pixel_size;
  
@@@ -60,87 -60,97 +60,90 @@@ typedef struct EightBpsContext 
   * Decode a frame
   *
   */
- static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
+ static int decode_frame(AVCodecContext *avctx, void *data,
+                         int *data_size, AVPacket *avpkt)
  {
-         const uint8_t *buf = avpkt->data;
-         int buf_size = avpkt->size;
-         EightBpsContext * const c = avctx->priv_data;
-         const unsigned char *encoded = buf;
-         unsigned char *pixptr, *pixptr_end;
-         unsigned int height = avctx->height; // Real image height
-         unsigned int dlen, p, row;
-         const unsigned char *lp, *dp;
-         unsigned char count;
-         unsigned int planes = c->planes;
-         unsigned char *planemap = c->planemap;
-         if(c->pic.data[0])
-                 avctx->release_buffer(avctx, &c->pic);
-         c->pic.reference = 0;
-         c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
-         if(avctx->get_buffer(avctx, &c->pic) < 0){
-                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
-                 return -1;
-         }
-         /* Set data pointer after line lengths */
-         dp = encoded + planes * (height << 1);
-         for (p = 0; p < planes; p++) {
-                 /* Lines length pointer for this plane */
-                 lp = encoded + p * (height << 1);
-                 /* Decode a plane */
-                 for(row = 0; row < height; row++) {
-                         pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
-                         pixptr_end = pixptr + c->pic.linesize[0];
-                         dlen = av_be2ne16(*(const unsigned short *)(lp+row*2));
-                         /* Decode a row of this plane */
-                         while(dlen > 0) {
-                                 if(dp + 1 >= buf+buf_size) return -1;
-                                 if ((count = *dp++) <= 127) {
-                                         count++;
-                                         dlen -= count + 1;
-                                         if (pixptr + count * planes > pixptr_end)
-                                             break;
-                                         if(dp + count > buf+buf_size) return -1;
-                                         while(count--) {
-                                                 *pixptr = *dp++;
-                                                 pixptr += planes;
-                                         }
-                                 } else {
-                                         count = 257 - count;
-                                         if (pixptr + count * planes > pixptr_end)
-                                             break;
-                                         while(count--) {
-                                                 *pixptr = *dp;
-                                                 pixptr += planes;
-                                         }
-                                         dp++;
-                                         dlen -= 2;
-                                 }
-                         }
+     const uint8_t *buf = avpkt->data;
+     int buf_size       = avpkt->size;
+     EightBpsContext * const c = avctx->priv_data;
+     const unsigned char *encoded = buf;
+     unsigned char *pixptr, *pixptr_end;
+     unsigned int height = avctx->height; // Real image height
+     unsigned int dlen, p, row;
+     const unsigned char *lp, *dp;
+     unsigned char count;
 -    unsigned int px_inc;
+     unsigned int planes     = c->planes;
+     unsigned char *planemap = c->planemap;
+     if (c->pic.data[0])
+         avctx->release_buffer(avctx, &c->pic);
+     c->pic.reference    = 0;
+     c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
+     if (avctx->get_buffer(avctx, &c->pic) < 0){
+         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+         return -1;
+     }
+     /* Set data pointer after line lengths */
+     dp = encoded + planes * (height << 1);
 -    /* Ignore alpha plane, don't know what to do with it */
 -    if (planes == 4)
 -        planes--;
 -
 -    px_inc = planes + (avctx->pix_fmt == PIX_FMT_RGB32);
 -
+     for (p = 0; p < planes; p++) {
+         /* Lines length pointer for this plane */
+         lp = encoded + p * (height << 1);
+         /* Decode a plane */
+         for (row = 0; row < height; row++) {
+             pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
+             pixptr_end = pixptr + c->pic.linesize[0];
+             dlen = av_be2ne16(*(const unsigned short *)(lp + row * 2));
+             /* Decode a row of this plane */
+             while (dlen > 0) {
+                 if (dp + 1 >= buf + buf_size)
+                     return -1;
+                 if ((count = *dp++) <= 127) {
+                     count++;
+                     dlen -= count + 1;
 -                    if (pixptr + count * px_inc > pixptr_end)
++                    if (pixptr + count * planes > pixptr_end)
+                         break;
+                     if (dp + count > buf + buf_size)
+                         return -1;
+                     while (count--) {
+                         *pixptr = *dp++;
 -                        pixptr += px_inc;
++                        pixptr += planes;
+                     }
+                 } else {
+                     count = 257 - count;
 -                    if (pixptr + count * px_inc > pixptr_end)
++                    if (pixptr + count * planes > pixptr_end)
+                         break;
+                     while (count--) {
+                         *pixptr = *dp;
 -                        pixptr += px_inc;
++                        pixptr += planes;
+                     }
+                     dp++;
+                     dlen -= 2;
                  }
+             }
          }
-         if (avctx->bits_per_coded_sample <= 8) {
-                 const uint8_t *pal = av_packet_get_side_data(avpkt,
-                                                              AV_PKT_DATA_PALETTE,
-                                                              NULL);
-                 if (pal) {
-                         c->pic.palette_has_changed = 1;
-                         memcpy(c->pal, pal, AVPALETTE_SIZE);
-                 }
-                 memcpy (c->pic.data[1], c->pal, AVPALETTE_SIZE);
+     }
+     if (avctx->bits_per_coded_sample <= 8) {
+         const uint8_t *pal = av_packet_get_side_data(avpkt,
+                                                      AV_PKT_DATA_PALETTE,
+                                                      NULL);
+         if (pal) {
+             c->pic.palette_has_changed = 1;
+             memcpy(c->pal, pal, AVPALETTE_SIZE);
          }
  
-         *data_size = sizeof(AVFrame);
-         *(AVFrame*)data = c->pic;
+         memcpy (c->pic.data[1], c->pal, AVPALETTE_SIZE);
+     }
+     *data_size = sizeof(AVFrame);
+     *(AVFrame*)data = c->pic;
  
-         /* always report that the buffer was completely consumed */
-         return buf_size;
+     /* always report that the buffer was completely consumed */
+     return buf_size;
  }
  
  
   */
  static av_cold int decode_init(AVCodecContext *avctx)
  {
-         EightBpsContext * const c = avctx->priv_data;
-         c->avctx = avctx;
-         avcodec_get_frame_defaults(&c->pic);
-         c->pic.data[0] = NULL;
-         switch (avctx->bits_per_coded_sample) {
-                 case 8:
-                         avctx->pix_fmt = PIX_FMT_PAL8;
-                         c->planes = 1;
-                         c->planemap[0] = 0; // 1st plane is palette indexes
-                         break;
-                 case 24:
-                         avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24);
-                         c->planes = 3;
-                         c->planemap[0] = 2; // 1st plane is red
-                         c->planemap[1] = 1; // 2nd plane is green
-                         c->planemap[2] = 0; // 3rd plane is blue
-                         break;
-                 case 32:
-                         avctx->pix_fmt = PIX_FMT_RGB32;
-                         c->planes = 4;
+     EightBpsContext * const c = avctx->priv_data;
+     c->avctx       = avctx;
+     c->pic.data[0] = NULL;
++    avcodec_get_frame_defaults(&c->pic);
+     switch (avctx->bits_per_coded_sample) {
+     case 8:
+         avctx->pix_fmt = PIX_FMT_PAL8;
+         c->planes      = 1;
+         c->planemap[0] = 0; // 1st plane is palette indexes
+         break;
+     case 24:
+         avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24);
+         c->planes      = 3;
+         c->planemap[0] = 2; // 1st plane is red
+         c->planemap[1] = 1; // 2nd plane is green
+         c->planemap[2] = 0; // 3rd plane is blue
+         break;
+     case 32:
+         avctx->pix_fmt = PIX_FMT_RGB32;
+         c->planes      = 4;
  #if HAVE_BIGENDIAN
-                         c->planemap[0] = 1; // 1st plane is red
-                         c->planemap[1] = 2; // 2nd plane is green
-                         c->planemap[2] = 3; // 3rd plane is blue
-                         c->planemap[3] = 0; // 4th plane is alpha
+         c->planemap[0] = 1; // 1st plane is red
+         c->planemap[1] = 2; // 2nd plane is green
+         c->planemap[2] = 3; // 3rd plane is blue
 -        c->planemap[3] = 0; // 4th plane is alpha???
++        c->planemap[3] = 0; // 4th plane is alpha
  #else
-                         c->planemap[0] = 2; // 1st plane is red
-                         c->planemap[1] = 1; // 2nd plane is green
-                         c->planemap[2] = 0; // 3rd plane is blue
-                         c->planemap[3] = 3; // 4th plane is alpha
+         c->planemap[0] = 2; // 1st plane is red
+         c->planemap[1] = 1; // 2nd plane is green
+         c->planemap[2] = 0; // 3rd plane is blue
 -        c->planemap[3] = 3; // 4th plane is alpha???
++        c->planemap[3] = 3; // 4th plane is alpha
  #endif
-                         break;
-                 default:
-                         av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n", avctx->bits_per_coded_sample);
-                         return -1;
-         }
-   return 0;
+         break;
+     default:
+         av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n",
+                avctx->bits_per_coded_sample);
+         return -1;
+     }
+     return 0;
  }
  
  
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -34,6 -34,6 +34,7 @@@
  #include "libavutil/log.h"
  #include "libavutil/pixfmt.h"
  #include "libavutil/rational.h"
++#include "libavutil/audioconvert.h"
  
  #include "libavcodec/version.h"
  /**
@@@ -355,10 -346,10 +356,6 @@@ enum CodecID 
      CODEC_ID_MACE3,
      CODEC_ID_MACE6,
      CODEC_ID_VMDAUDIO,
--#if LIBAVCODEC_VERSION_MAJOR == 53
--    CODEC_ID_SONIC,
--    CODEC_ID_SONIC_LS,
--#endif
      CODEC_ID_FLAC,
      CODEC_ID_MP3ADU,
      CODEC_ID_MP3ON4,
      CODEC_ID_8SVX_FIB,
  #endif
      CODEC_ID_BMV_AUDIO,
 +    CODEC_ID_G729 = 0x15800,
 +    CODEC_ID_G723_1= 0x15801,
 +    CODEC_ID_FFWAVESYNTH = MKBETAG('F','F','W','S'),
 +    CODEC_ID_8SVX_RAW   = MKBETAG('8','S','V','X'),
++    CODEC_ID_SONIC       = MKBETAG('S','O','N','C'),
++    CODEC_ID_SONIC_LS    = MKBETAG('S','O','N','L'),
  
      /* subtitle codecs */
      CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
@@@ -679,51 -586,8 +604,10 @@@ typedef struct RcOverride
  #define CODEC_FLAG2_STRICT_GOP    0x00000002 ///< Strictly enforce GOP size.
  #define CODEC_FLAG2_NO_OUTPUT     0x00000004 ///< Skip bitstream encoding.
  #define CODEC_FLAG2_LOCAL_HEADER  0x00000008 ///< Place global headers at every keyframe instead of in extradata.
++#define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format. DEPRECATED!!!!
  #define CODEC_FLAG2_SKIP_RD       0x00004000 ///< RD optimal MB level residual skipping
  #define CODEC_FLAG2_CHUNKS        0x00008000 ///< Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
- /**
-  * @defgroup deprecated_flags Deprecated codec flags
-  * Use corresponding private codec options instead.
-  * @{
-  */
- #if FF_API_MPEGVIDEO_GLOBAL_OPTS
- #define CODEC_FLAG_OBMC           0x00000001 ///< OBMC
- #define CODEC_FLAG_H263P_AIV      0x00000008 ///< H.263 alternative inter VLC
- #define CODEC_FLAG_PART   0x0080  ///< Use data partitioning.
- #define CODEC_FLAG_ALT_SCAN       0x00100000 ///< Use alternate scan.
- #define CODEC_FLAG_H263P_UMV      0x02000000 ///< unlimited motion vector
- #define CODEC_FLAG_H263P_SLICE_STRUCT 0x10000000
- #define CODEC_FLAG_SVCD_SCAN_OFFSET 0x40000000 ///< Will reserve space for SVCD scan offset user data.
- #define CODEC_FLAG2_INTRA_VLC     0x00000800 ///< Use MPEG-2 intra VLC table.
- #define CODEC_FLAG2_DROP_FRAME_TIMECODE 0x00002000 ///< timecode is in drop frame format.
- #define CODEC_FLAG2_NON_LINEAR_QUANT 0x00010000 ///< Use MPEG-2 nonlinear quantizer.
- #endif
- #if FF_API_MJPEG_GLOBAL_OPTS
- #define CODEC_FLAG_EXTERN_HUFF     0x1000   ///< Use external Huffman table (for MJPEG).
- #endif
- #if FF_API_X264_GLOBAL_OPTS
- #define CODEC_FLAG2_BPYRAMID      0x00000010 ///< H.264 allow B-frames to be used as references.
- #define CODEC_FLAG2_WPRED         0x00000020 ///< H.264 weighted biprediction for B-frames
- #define CODEC_FLAG2_MIXED_REFS    0x00000040 ///< H.264 one reference per partition, as opposed to one reference per macroblock
- #define CODEC_FLAG2_8X8DCT        0x00000080 ///< H.264 high profile 8x8 transform
- #define CODEC_FLAG2_FASTPSKIP     0x00000100 ///< H.264 fast pskip
- #define CODEC_FLAG2_AUD           0x00000200 ///< H.264 access unit delimiters
- #define CODEC_FLAG2_BRDO          0x00000400 ///< B-frame rate-distortion optimization
- #define CODEC_FLAG2_MBTREE        0x00040000 ///< Use macroblock tree ratecontrol (x264 only)
- #define CODEC_FLAG2_PSY           0x00080000 ///< Use psycho visual optimizations.
- #define CODEC_FLAG2_SSIM          0x00100000 ///< Compute SSIM during encoding, error[] values are undefined.
- #define CODEC_FLAG2_INTRA_REFRESH 0x00200000 ///< Use periodic insertion of intra blocks instead of keyframes.
- #endif
- #if FF_API_SNOW_GLOBAL_OPTS
- #define CODEC_FLAG2_MEMC_ONLY     0x00001000 ///< Only do ME/MC (I frames -> ref, P frame -> ME+MC).
- #endif
- #if FF_API_LAME_GLOBAL_OPTS
- #define CODEC_FLAG2_BIT_RESERVOIR 0x00020000 ///< Use a bit reservoir when encoding if possible
- #endif
- /**
-  * @}
-  */
 +#define CODEC_FLAG2_SHOW_ALL      0x00400000 ///< Show all frames before the first keyframe
  
  /* Unsupported options :
   *              Syntax Arithmetic coding (SAC)
@@@ -1006,19 -849,12 +875,15 @@@ enum AVSideDataParamChangeFlags 
  /**
   * Audio Video Frame.
   * New fields can be added to the end of AVFRAME with minor version
 - * bumps. Removal, reordering and changes to existing fields require
 + * bumps. Similarly fields that are marked as to be only accessed by
 + * av_opt_ptr() can be reordered. This allows 2 forks to add fields
 + * without breaking compatibility with each other.
 + * Removal, reordering and changes in the remaining cases require
   * a major version bump.
 - * sizeof(AVFrame) must not be used outside libav*.
 + * sizeof(AVFrame) must not be used outside libavcodec.
   */
  typedef struct AVFrame {
- #if FF_API_DATA_POINTERS
- #define AV_NUM_DATA_POINTERS 4
- #else
  #define AV_NUM_DATA_POINTERS 8
- #endif
      /**
       * pointer to the picture/channel planes.
       * This might be different from the first allocated byte
@@@ -2835,47 -2507,10 +2559,10 @@@ typedef struct AVCodecContext 
       */
      int max_prediction_order;
  
- #if FF_API_FLAC_GLOBAL_OPTS
-     /**
-      * @name FLAC options
-      * @deprecated Use FLAC encoder private options instead.
-      * @{
-      */
-     /**
-      * LPC coefficient precision - used by FLAC encoder
-      * - encoding: Set by user.
-      * - decoding: unused
-      */
-     attribute_deprecated int lpc_coeff_precision;
-     /**
-      * search method for selecting prediction order
-      * - encoding: Set by user.
-      * - decoding: unused
-      */
-     attribute_deprecated int prediction_order_method;
-     /**
-      * - encoding: Set by user.
-      * - decoding: unused
-      */
-     attribute_deprecated int min_partition_order;
-     /**
-      * - encoding: Set by user.
-      * - decoding: unused
-      */
-     attribute_deprecated int max_partition_order;
-     /**
-      * @}
-      */
- #endif
      /**
 -     * GOP timecode frame start number, in non drop frame format
 -     * - encoding: Set by user.
 -     * - decoding: unused
 +     * GOP timecode frame start number
 +     * - encoding: Set by user, in non drop frame format
 +     * - decoding: Set by libavcodec (timecode in the 25 bits format, -1 if unset)
       */
      int64_t timecode_frame_start;
  
@@@ -3758,23 -3246,6 +3319,12 @@@ int avpicture_layout(const AVPicture* s
  int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height);
  void avcodec_get_chroma_sub_sample(enum PixelFormat pix_fmt, int *h_shift, int *v_shift);
  
- #if FF_API_GET_PIX_FMT_NAME
- /**
-  * Return the short name for a pixel format.
-  *
-  * \see av_get_pix_fmt(), av_get_pix_fmt_string().
-  * @deprecated Deprecated in favor of av_get_pix_fmt_name().
-  */
- attribute_deprecated
- const char *avcodec_get_pix_fmt_name(enum PixelFormat pix_fmt);
- #endif
 +/**
 + * Get the name of a codec.
 + * @return  a static string identifying the codec; never NULL
 + */
 +const char *avcodec_get_name(enum CodecID id);
 +
  void avcodec_set_dimensions(AVCodecContext *s, int width, int height);
  
  /**
@@@ -3848,52 -3316,6 +3398,40 @@@ int avcodec_get_pix_fmt_loss(enum Pixel
  enum PixelFormat avcodec_find_best_pix_fmt(int64_t pix_fmt_mask, enum PixelFormat src_pix_fmt,
                                int has_alpha, int *loss_ptr);
  
- #if FF_API_GET_ALPHA_INFO
- #define FF_ALPHA_TRANSP       0x0001 /* image has some totally transparent pixels */
- #define FF_ALPHA_SEMI_TRANSP  0x0002 /* image has some transparent pixels */
- /**
-  * Tell if an image really has transparent alpha values.
-  * @return ored mask of FF_ALPHA_xxx constants
-  */
- attribute_deprecated
- int img_get_alpha_info(const AVPicture *src,
-                        enum PixelFormat pix_fmt, int width, int height);
- #endif
 +/**
 + * Find the best pixel format to convert to given a certain source pixel
 + * format and a selection of two destination pixel formats. When converting from
 + * one pixel format to another, information loss may occur.  For example, when converting
 + * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
 + * converting from some formats to other formats. avcodec_find_best_pix_fmt2() selects which of
 + * the given pixel formats should be used to suffer the least amount of loss.
 + *
 + * If one of the destination formats is PIX_FMT_NONE the other pixel format (if valid) will be
 + * returned.
 + *
 + * @code
 + * src_pix_fmt = PIX_FMT_YUV420P;
 + * dst_pix_fmt1= PIX_FMT_RGB24;
 + * dst_pix_fmt2= PIX_FMT_GRAY8;
 + * dst_pix_fmt3= PIX_FMT_RGB8;
 + * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
 + * dst_pix_fmt = avcodec_find_best_pix_fmt2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
 + * @endcode
 + *
 + * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
 + * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
 + * @param[in] src_pix_fmt Source pixel format
 + * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 + * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
 + *                               NULL or value of zero means we care about all losses. Out: the loss
 + *                               that occurs when converting from src to selected dst pixel format.
 + * @return The best pixel format to convert to or -1 if none was found.
 + */
 +enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,
 +                                            enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
 +
  /* deinterlace a picture */
  /* deinterlace - if not supported return -1 */
  int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
Simple merge
Simple merge
index ec70e06,0000000..711fa56
mode 100644,000000..100644
--- /dev/null
@@@ -1,2230 -1,0 +1,2230 @@@
-     .sample_fmts    = (const enum SampleFormat[]){AV_SAMPLE_FMT_S16,
-                                                   AV_SAMPLE_FMT_NONE},
 +/*
 + * G.723.1 compatible decoder
 + * Copyright (c) 2006 Benjamin Larsson
 + * Copyright (c) 2010 Mohamed Naufal Basheer
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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
 + */
 +
 +/**
 + * @file
 + * G.723.1 compatible decoder
 + */
 +
 +#include "avcodec.h"
 +#define BITSTREAM_READER_LE
 +#include "get_bits.h"
 +#include "acelp_vectors.h"
 +#include "celp_filters.h"
 +#include "celp_math.h"
 +#include "lsp.h"
 +#include "libavutil/lzo.h"
 +#include "g723_1_data.h"
 +
 +typedef struct g723_1_context {
 +    AVFrame frame;
 +    G723_1_Subframe subframe[4];
 +    FrameType cur_frame_type;
 +    FrameType past_frame_type;
 +    Rate cur_rate;
 +    uint8_t lsp_index[LSP_BANDS];
 +    int pitch_lag[2];
 +    int erased_frames;
 +
 +    int16_t prev_lsp[LPC_ORDER];
 +    int16_t prev_excitation[PITCH_MAX];
 +    int16_t excitation[PITCH_MAX + FRAME_LEN];
 +    int16_t synth_mem[LPC_ORDER];
 +    int16_t fir_mem[LPC_ORDER];
 +    int     iir_mem[LPC_ORDER];
 +
 +    int random_seed;
 +    int interp_index;
 +    int interp_gain;
 +    int sid_gain;
 +    int cur_gain;
 +    int reflection_coef;
 +    int pf_gain;                 ///< formant postfilter
 +                                 ///< gain scaling unit memory
 +
 +    int16_t prev_data[HALF_FRAME_LEN];
 +    int16_t prev_weight_sig[PITCH_MAX];
 +
 +
 +    int16_t hpf_fir_mem;                   ///< highpass filter fir
 +    int     hpf_iir_mem;                   ///< and iir memories
 +    int16_t perf_fir_mem[LPC_ORDER];       ///< perceptual filter fir
 +    int16_t perf_iir_mem[LPC_ORDER];       ///< and iir memories
 +
 +    int16_t harmonic_mem[PITCH_MAX];
 +} G723_1_Context;
 +
 +static av_cold int g723_1_decode_init(AVCodecContext *avctx)
 +{
 +    G723_1_Context *p  = avctx->priv_data;
 +
 +    avctx->sample_fmt  = AV_SAMPLE_FMT_S16;
 +    p->pf_gain         = 1 << 12;
 +    memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(int16_t));
 +
 +    avcodec_get_frame_defaults(&p->frame);
 +    avctx->coded_frame = &p->frame;
 +
 +    return 0;
 +}
 +
 +/**
 + * Unpack the frame into parameters.
 + *
 + * @param p           the context
 + * @param buf         pointer to the input buffer
 + * @param buf_size    size of the input buffer
 + */
 +static int unpack_bitstream(G723_1_Context *p, const uint8_t *buf,
 +                            int buf_size)
 +{
 +    GetBitContext gb;
 +    int ad_cb_len;
 +    int temp, info_bits, i;
 +
 +    init_get_bits(&gb, buf, buf_size * 8);
 +
 +    /* Extract frame type and rate info */
 +    info_bits = get_bits(&gb, 2);
 +
 +    if (info_bits == 3) {
 +        p->cur_frame_type = UntransmittedFrame;
 +        return 0;
 +    }
 +
 +    /* Extract 24 bit lsp indices, 8 bit for each band */
 +    p->lsp_index[2] = get_bits(&gb, 8);
 +    p->lsp_index[1] = get_bits(&gb, 8);
 +    p->lsp_index[0] = get_bits(&gb, 8);
 +
 +    if (info_bits == 2) {
 +        p->cur_frame_type = SIDFrame;
 +        p->subframe[0].amp_index = get_bits(&gb, 6);
 +        return 0;
 +    }
 +
 +    /* Extract the info common to both rates */
 +    p->cur_rate       = info_bits ? Rate5k3 : Rate6k3;
 +    p->cur_frame_type = ActiveFrame;
 +
 +    p->pitch_lag[0] = get_bits(&gb, 7);
 +    if (p->pitch_lag[0] > 123)       /* test if forbidden code */
 +        return -1;
 +    p->pitch_lag[0] += PITCH_MIN;
 +    p->subframe[1].ad_cb_lag = get_bits(&gb, 2);
 +
 +    p->pitch_lag[1] = get_bits(&gb, 7);
 +    if (p->pitch_lag[1] > 123)
 +        return -1;
 +    p->pitch_lag[1] += PITCH_MIN;
 +    p->subframe[3].ad_cb_lag = get_bits(&gb, 2);
 +    p->subframe[0].ad_cb_lag = 1;
 +    p->subframe[2].ad_cb_lag = 1;
 +
 +    for (i = 0; i < SUBFRAMES; i++) {
 +        /* Extract combined gain */
 +        temp = get_bits(&gb, 12);
 +        ad_cb_len = 170;
 +        p->subframe[i].dirac_train = 0;
 +        if (p->cur_rate == Rate6k3 && p->pitch_lag[i >> 1] < SUBFRAME_LEN - 2) {
 +            p->subframe[i].dirac_train = temp >> 11;
 +            temp &= 0x7ff;
 +            ad_cb_len = 85;
 +        }
 +        p->subframe[i].ad_cb_gain = FASTDIV(temp, GAIN_LEVELS);
 +        if (p->subframe[i].ad_cb_gain < ad_cb_len) {
 +            p->subframe[i].amp_index = temp - p->subframe[i].ad_cb_gain *
 +                                       GAIN_LEVELS;
 +        } else {
 +            return -1;
 +        }
 +    }
 +
 +    p->subframe[0].grid_index = get_bits1(&gb);
 +    p->subframe[1].grid_index = get_bits1(&gb);
 +    p->subframe[2].grid_index = get_bits1(&gb);
 +    p->subframe[3].grid_index = get_bits1(&gb);
 +
 +    if (p->cur_rate == Rate6k3) {
 +        skip_bits1(&gb);  /* skip reserved bit */
 +
 +        /* Compute pulse_pos index using the 13-bit combined position index */
 +        temp = get_bits(&gb, 13);
 +        p->subframe[0].pulse_pos = temp / 810;
 +
 +        temp -= p->subframe[0].pulse_pos * 810;
 +        p->subframe[1].pulse_pos = FASTDIV(temp, 90);
 +
 +        temp -= p->subframe[1].pulse_pos * 90;
 +        p->subframe[2].pulse_pos = FASTDIV(temp, 9);
 +        p->subframe[3].pulse_pos = temp - p->subframe[2].pulse_pos * 9;
 +
 +        p->subframe[0].pulse_pos = (p->subframe[0].pulse_pos << 16) +
 +                                   get_bits(&gb, 16);
 +        p->subframe[1].pulse_pos = (p->subframe[1].pulse_pos << 14) +
 +                                   get_bits(&gb, 14);
 +        p->subframe[2].pulse_pos = (p->subframe[2].pulse_pos << 16) +
 +                                   get_bits(&gb, 16);
 +        p->subframe[3].pulse_pos = (p->subframe[3].pulse_pos << 14) +
 +                                   get_bits(&gb, 14);
 +
 +        p->subframe[0].pulse_sign = get_bits(&gb, 6);
 +        p->subframe[1].pulse_sign = get_bits(&gb, 5);
 +        p->subframe[2].pulse_sign = get_bits(&gb, 6);
 +        p->subframe[3].pulse_sign = get_bits(&gb, 5);
 +    } else { /* Rate5k3 */
 +        p->subframe[0].pulse_pos  = get_bits(&gb, 12);
 +        p->subframe[1].pulse_pos  = get_bits(&gb, 12);
 +        p->subframe[2].pulse_pos  = get_bits(&gb, 12);
 +        p->subframe[3].pulse_pos  = get_bits(&gb, 12);
 +
 +        p->subframe[0].pulse_sign = get_bits(&gb, 4);
 +        p->subframe[1].pulse_sign = get_bits(&gb, 4);
 +        p->subframe[2].pulse_sign = get_bits(&gb, 4);
 +        p->subframe[3].pulse_sign = get_bits(&gb, 4);
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * Bitexact implementation of sqrt(val/2).
 + */
 +static int16_t square_root(int val)
 +{
 +    return (ff_sqrt(val << 1) >> 1) & (~1);
 +}
 +
 +/**
 + * Calculate the number of left-shifts required for normalizing the input.
 + *
 + * @param num   input number
 + * @param width width of the input, 16 bits(0) / 32 bits(1)
 + */
 +static int normalize_bits(int num, int width)
 +{
 +    int i = 0;
 +    int bits = (width) ? 31 : 15;
 +
 +    if (num) {
 +        if (num == -1)
 +            return bits;
 +        if (num < 0)
 +            num = ~num;
 +        i= bits - av_log2(num) - 1;
 +        i= FFMAX(i, 0);
 +    }
 +    return i;
 +}
 +
 +#define normalize_bits_int16(num) normalize_bits(num, 0)
 +#define normalize_bits_int32(num) normalize_bits(num, 1)
 +#define dot_product(a,b,c,d) (ff_dot_product(a,b,c)<<(d))
 +
 +/**
 + * Scale vector contents based on the largest of their absolutes.
 + */
 +static int scale_vector(int16_t *vector, int length)
 +{
 +    int bits, scale, max = 0;
 +    int i;
 +
 +    const int16_t shift_table[16] = {
 +        0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
 +        0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x7fff
 +    };
 +
 +    for (i = 0; i < length; i++)
 +        max = FFMAX(max, FFABS(vector[i]));
 +
 +    bits  = normalize_bits(max, 0);
 +    scale = shift_table[bits];
 +
 +    for (i = 0; i < length; i++)
 +        vector[i] = (vector[i] * scale) >> 3;
 +
 +    return bits - 3;
 +}
 +
 +/**
 + * Perform inverse quantization of LSP frequencies.
 + *
 + * @param cur_lsp    the current LSP vector
 + * @param prev_lsp   the previous LSP vector
 + * @param lsp_index  VQ indices
 + * @param bad_frame  bad frame flag
 + */
 +static void inverse_quant(int16_t *cur_lsp, int16_t *prev_lsp,
 +                          uint8_t *lsp_index, int bad_frame)
 +{
 +    int min_dist, pred;
 +    int i, j, temp, stable;
 +
 +    /* Check for frame erasure */
 +    if (!bad_frame) {
 +        min_dist     = 0x100;
 +        pred         = 12288;
 +    } else {
 +        min_dist     = 0x200;
 +        pred         = 23552;
 +        lsp_index[0] = lsp_index[1] = lsp_index[2] = 0;
 +    }
 +
 +    /* Get the VQ table entry corresponding to the transmitted index */
 +    cur_lsp[0] = lsp_band0[lsp_index[0]][0];
 +    cur_lsp[1] = lsp_band0[lsp_index[0]][1];
 +    cur_lsp[2] = lsp_band0[lsp_index[0]][2];
 +    cur_lsp[3] = lsp_band1[lsp_index[1]][0];
 +    cur_lsp[4] = lsp_band1[lsp_index[1]][1];
 +    cur_lsp[5] = lsp_band1[lsp_index[1]][2];
 +    cur_lsp[6] = lsp_band2[lsp_index[2]][0];
 +    cur_lsp[7] = lsp_band2[lsp_index[2]][1];
 +    cur_lsp[8] = lsp_band2[lsp_index[2]][2];
 +    cur_lsp[9] = lsp_band2[lsp_index[2]][3];
 +
 +    /* Add predicted vector & DC component to the previously quantized vector */
 +    for (i = 0; i < LPC_ORDER; i++) {
 +        temp        = ((prev_lsp[i] - dc_lsp[i]) * pred + (1 << 14)) >> 15;
 +        cur_lsp[i] += dc_lsp[i] + temp;
 +    }
 +
 +    for (i = 0; i < LPC_ORDER; i++) {
 +        cur_lsp[0]             = FFMAX(cur_lsp[0],  0x180);
 +        cur_lsp[LPC_ORDER - 1] = FFMIN(cur_lsp[LPC_ORDER - 1], 0x7e00);
 +
 +        /* Stability check */
 +        for (j = 1; j < LPC_ORDER; j++) {
 +            temp = min_dist + cur_lsp[j - 1] - cur_lsp[j];
 +            if (temp > 0) {
 +                temp >>= 1;
 +                cur_lsp[j - 1] -= temp;
 +                cur_lsp[j]     += temp;
 +            }
 +        }
 +        stable = 1;
 +        for (j = 1; j < LPC_ORDER; j++) {
 +            temp = cur_lsp[j - 1] + min_dist - cur_lsp[j] - 4;
 +            if (temp > 0) {
 +                stable = 0;
 +                break;
 +            }
 +        }
 +        if (stable)
 +            break;
 +    }
 +    if (!stable)
 +        memcpy(cur_lsp, prev_lsp, LPC_ORDER * sizeof(int16_t));
 +}
 +
 +/**
 + * Bitexact implementation of 2ab scaled by 1/2^16.
 + *
 + * @param a 32 bit multiplicand
 + * @param b 16 bit multiplier
 + */
 +#define MULL2(a, b) \
 +        MULL(a,b,15)
 +
 +/**
 + * Convert LSP frequencies to LPC coefficients.
 + *
 + * @param lpc buffer for LPC coefficients
 + */
 +static void lsp2lpc(int16_t *lpc)
 +{
 +    int f1[LPC_ORDER / 2 + 1];
 +    int f2[LPC_ORDER / 2 + 1];
 +    int i, j;
 +
 +    /* Calculate negative cosine */
 +    for (j = 0; j < LPC_ORDER; j++) {
 +        int index     = lpc[j] >> 7;
 +        int offset    = lpc[j] & 0x7f;
 +        int64_t temp1 = cos_tab[index] << 16;
 +        int temp2     = (cos_tab[index + 1] - cos_tab[index]) *
 +                          ((offset << 8) + 0x80) << 1;
 +
 +        lpc[j] = -(av_clipl_int32(((temp1 + temp2) << 1) + (1 << 15)) >> 16);
 +    }
 +
 +    /*
 +     * Compute sum and difference polynomial coefficients
 +     * (bitexact alternative to lsp2poly() in lsp.c)
 +     */
 +    /* Initialize with values in Q28 */
 +    f1[0] = 1 << 28;
 +    f1[1] = (lpc[0] << 14) + (lpc[2] << 14);
 +    f1[2] = lpc[0] * lpc[2] + (2 << 28);
 +
 +    f2[0] = 1 << 28;
 +    f2[1] = (lpc[1] << 14) + (lpc[3] << 14);
 +    f2[2] = lpc[1] * lpc[3] + (2 << 28);
 +
 +    /*
 +     * Calculate and scale the coefficients by 1/2 in
 +     * each iteration for a final scaling factor of Q25
 +     */
 +    for (i = 2; i < LPC_ORDER / 2; i++) {
 +        f1[i + 1] = f1[i - 1] + MULL2(f1[i], lpc[2 * i]);
 +        f2[i + 1] = f2[i - 1] + MULL2(f2[i], lpc[2 * i + 1]);
 +
 +        for (j = i; j >= 2; j--) {
 +            f1[j] = MULL2(f1[j - 1], lpc[2 * i]) +
 +                    (f1[j] >> 1) + (f1[j - 2] >> 1);
 +            f2[j] = MULL2(f2[j - 1], lpc[2 * i + 1]) +
 +                    (f2[j] >> 1) + (f2[j - 2] >> 1);
 +        }
 +
 +        f1[0] >>= 1;
 +        f2[0] >>= 1;
 +        f1[1] = ((lpc[2 * i]     << 16 >> i) + f1[1]) >> 1;
 +        f2[1] = ((lpc[2 * i + 1] << 16 >> i) + f2[1]) >> 1;
 +    }
 +
 +    /* Convert polynomial coefficients to LPC coefficients */
 +    for (i = 0; i < LPC_ORDER / 2; i++) {
 +        int64_t ff1 = f1[i + 1] + f1[i];
 +        int64_t ff2 = f2[i + 1] - f2[i];
 +
 +        lpc[i] = av_clipl_int32(((ff1 + ff2) << 3) + (1 << 15)) >> 16;
 +        lpc[LPC_ORDER - i - 1] = av_clipl_int32(((ff1 - ff2) << 3) +
 +                                                (1 << 15)) >> 16;
 +    }
 +}
 +
 +/**
 + * Quantize LSP frequencies by interpolation and convert them to
 + * the corresponding LPC coefficients.
 + *
 + * @param lpc      buffer for LPC coefficients
 + * @param cur_lsp  the current LSP vector
 + * @param prev_lsp the previous LSP vector
 + */
 +static void lsp_interpolate(int16_t *lpc, int16_t *cur_lsp, int16_t *prev_lsp)
 +{
 +    int i;
 +    int16_t *lpc_ptr = lpc;
 +
 +    /* cur_lsp * 0.25 + prev_lsp * 0.75 */
 +    ff_acelp_weighted_vector_sum(lpc, cur_lsp, prev_lsp,
 +                                 4096, 12288, 1 << 13, 14, LPC_ORDER);
 +    ff_acelp_weighted_vector_sum(lpc + LPC_ORDER, cur_lsp, prev_lsp,
 +                                 8192, 8192, 1 << 13, 14, LPC_ORDER);
 +    ff_acelp_weighted_vector_sum(lpc + 2 * LPC_ORDER, cur_lsp, prev_lsp,
 +                                 12288, 4096, 1 << 13, 14, LPC_ORDER);
 +    memcpy(lpc + 3 * LPC_ORDER, cur_lsp, LPC_ORDER * sizeof(int16_t));
 +
 +    for (i = 0; i < SUBFRAMES; i++) {
 +        lsp2lpc(lpc_ptr);
 +        lpc_ptr += LPC_ORDER;
 +    }
 +}
 +
 +/**
 + * Generate a train of dirac functions with period as pitch lag.
 + */
 +static void gen_dirac_train(int16_t *buf, int pitch_lag)
 +{
 +    int16_t vector[SUBFRAME_LEN];
 +    int i, j;
 +
 +    memcpy(vector, buf, SUBFRAME_LEN * sizeof(int16_t));
 +    for (i = pitch_lag; i < SUBFRAME_LEN; i += pitch_lag) {
 +        for (j = 0; j < SUBFRAME_LEN - i; j++)
 +            buf[i + j] += vector[j];
 +    }
 +}
 +
 +/**
 + * Generate fixed codebook excitation vector.
 + *
 + * @param vector    decoded excitation vector
 + * @param subfrm    current subframe
 + * @param cur_rate  current bitrate
 + * @param pitch_lag closed loop pitch lag
 + * @param index     current subframe index
 + */
 +static void gen_fcb_excitation(int16_t *vector, G723_1_Subframe subfrm,
 +                               Rate cur_rate, int pitch_lag, int index)
 +{
 +    int temp, i, j;
 +
 +    memset(vector, 0, SUBFRAME_LEN * sizeof(int16_t));
 +
 +    if (cur_rate == Rate6k3) {
 +        if (subfrm.pulse_pos >= max_pos[index])
 +            return;
 +
 +        /* Decode amplitudes and positions */
 +        j = PULSE_MAX - pulses[index];
 +        temp = subfrm.pulse_pos;
 +        for (i = 0; i < SUBFRAME_LEN / GRID_SIZE; i++) {
 +            temp -= combinatorial_table[j][i];
 +            if (temp >= 0)
 +                continue;
 +            temp += combinatorial_table[j++][i];
 +            if (subfrm.pulse_sign & (1 << (PULSE_MAX - j))) {
 +                vector[subfrm.grid_index + GRID_SIZE * i] =
 +                                        -fixed_cb_gain[subfrm.amp_index];
 +            } else {
 +                vector[subfrm.grid_index + GRID_SIZE * i] =
 +                                         fixed_cb_gain[subfrm.amp_index];
 +            }
 +            if (j == PULSE_MAX)
 +                break;
 +        }
 +        if (subfrm.dirac_train == 1)
 +            gen_dirac_train(vector, pitch_lag);
 +    } else { /* Rate5k3 */
 +        int cb_gain  = fixed_cb_gain[subfrm.amp_index];
 +        int cb_shift = subfrm.grid_index;
 +        int cb_sign  = subfrm.pulse_sign;
 +        int cb_pos   = subfrm.pulse_pos;
 +        int offset, beta, lag;
 +
 +        for (i = 0; i < 8; i += 2) {
 +            offset         = ((cb_pos & 7) << 3) + cb_shift + i;
 +            vector[offset] = (cb_sign & 1) ? cb_gain : -cb_gain;
 +            cb_pos  >>= 3;
 +            cb_sign >>= 1;
 +        }
 +
 +        /* Enhance harmonic components */
 +        lag  = pitch_contrib[subfrm.ad_cb_gain << 1] + pitch_lag +
 +               subfrm.ad_cb_lag - 1;
 +        beta = pitch_contrib[(subfrm.ad_cb_gain << 1) + 1];
 +
 +        if (lag < SUBFRAME_LEN - 2) {
 +            for (i = lag; i < SUBFRAME_LEN; i++)
 +                vector[i] += beta * vector[i - lag] >> 15;
 +        }
 +    }
 +}
 +
 +/**
 + * Get delayed contribution from the previous excitation vector.
 + */
 +static void get_residual(int16_t *residual, int16_t *prev_excitation, int lag)
 +{
 +    int offset = PITCH_MAX - PITCH_ORDER / 2 - lag;
 +    int i;
 +
 +    residual[0] = prev_excitation[offset];
 +    residual[1] = prev_excitation[offset + 1];
 +
 +    offset += 2;
 +    for (i = 2; i < SUBFRAME_LEN + PITCH_ORDER - 1; i++)
 +        residual[i] = prev_excitation[offset + (i - 2) % lag];
 +}
 +
 +/**
 + * Generate adaptive codebook excitation.
 + */
 +static void gen_acb_excitation(int16_t *vector, int16_t *prev_excitation,
 +                               int pitch_lag, G723_1_Subframe subfrm,
 +                               Rate cur_rate)
 +{
 +    int16_t residual[SUBFRAME_LEN + PITCH_ORDER - 1];
 +    const int16_t *cb_ptr;
 +    int lag = pitch_lag + subfrm.ad_cb_lag - 1;
 +
 +    int i;
 +    int64_t sum;
 +
 +    get_residual(residual, prev_excitation, lag);
 +
 +    /* Select quantization table */
 +    if (cur_rate == Rate6k3 && pitch_lag < SUBFRAME_LEN - 2) {
 +        cb_ptr = adaptive_cb_gain85;
 +    } else
 +        cb_ptr = adaptive_cb_gain170;
 +
 +    /* Calculate adaptive vector */
 +    cb_ptr += subfrm.ad_cb_gain * 20;
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        sum = ff_dot_product(residual + i, cb_ptr, PITCH_ORDER);
 +        vector[i] = av_clipl_int32((sum << 2) + (1 << 15)) >> 16;
 +    }
 +}
 +
 +/**
 + * Estimate maximum auto-correlation around pitch lag.
 + *
 + * @param p         the context
 + * @param offset    offset of the excitation vector
 + * @param ccr_max   pointer to the maximum auto-correlation
 + * @param pitch_lag decoded pitch lag
 + * @param length    length of autocorrelation
 + * @param dir       forward lag(1) / backward lag(-1)
 + */
 +static int autocorr_max(G723_1_Context *p, int offset, int *ccr_max,
 +                        int pitch_lag, int length, int dir)
 +{
 +    int limit, ccr, lag = 0;
 +    int16_t *buf = p->excitation + offset;
 +    int i;
 +
 +    pitch_lag = FFMIN(PITCH_MAX - 3, pitch_lag);
 +    limit     = FFMIN(FRAME_LEN + PITCH_MAX - offset - length, pitch_lag + 3);
 +
 +    for (i = pitch_lag - 3; i <= limit; i++) {
 +        ccr = ff_dot_product(buf, buf + dir * i, length)<<1;
 +
 +        if (ccr > *ccr_max) {
 +            *ccr_max = ccr;
 +            lag = i;
 +        }
 +    }
 +    return lag;
 +}
 +
 +/**
 + * Calculate pitch postfilter optimal and scaling gains.
 + *
 + * @param lag      pitch postfilter forward/backward lag
 + * @param ppf      pitch postfilter parameters
 + * @param cur_rate current bitrate
 + * @param tgt_eng  target energy
 + * @param ccr      cross-correlation
 + * @param res_eng  residual energy
 + */
 +static void comp_ppf_gains(int lag, PPFParam *ppf, Rate cur_rate,
 +                           int tgt_eng, int ccr, int res_eng)
 +{
 +    int pf_residual;     /* square of postfiltered residual */
 +    int64_t temp1, temp2;
 +
 +    ppf->index = lag;
 +
 +    temp1 = tgt_eng * res_eng >> 1;
 +    temp2 = ccr * ccr << 1;
 +
 +    if (temp2 > temp1) {
 +        if (ccr >= res_eng) {
 +            ppf->opt_gain = ppf_gain_weight[cur_rate];
 +        } else {
 +            ppf->opt_gain = (ccr << 15) / res_eng *
 +                            ppf_gain_weight[cur_rate] >> 15;
 +        }
 +        /* pf_res^2 = tgt_eng + 2*ccr*gain + res_eng*gain^2 */
 +        temp1       = (tgt_eng << 15) + (ccr * ppf->opt_gain << 1);
 +        temp2       = (ppf->opt_gain * ppf->opt_gain >> 15) * res_eng;
 +        pf_residual = av_clipl_int32(temp1 + temp2 + (1 << 15)) >> 16;
 +
 +        if (tgt_eng >= pf_residual << 1) {
 +            temp1 = 0x7fff;
 +        } else {
 +            temp1 = (tgt_eng << 14) / pf_residual;
 +        }
 +
 +        /* scaling_gain = sqrt(tgt_eng/pf_res^2) */
 +        ppf->sc_gain = square_root(temp1 << 16);
 +    } else {
 +        ppf->opt_gain = 0;
 +        ppf->sc_gain  = 0x7fff;
 +    }
 +
 +    ppf->opt_gain = av_clip_int16(ppf->opt_gain * ppf->sc_gain >> 15);
 +}
 +
 +/**
 + * Calculate pitch postfilter parameters.
 + *
 + * @param p         the context
 + * @param offset    offset of the excitation vector
 + * @param pitch_lag decoded pitch lag
 + * @param ppf       pitch postfilter parameters
 + * @param cur_rate  current bitrate
 + */
 +static void comp_ppf_coeff(G723_1_Context *p, int offset, int pitch_lag,
 +                           PPFParam *ppf, Rate cur_rate)
 +{
 +
 +    int16_t scale;
 +    int i;
 +    int64_t temp1, temp2;
 +
 +    /*
 +     * 0 - target energy
 +     * 1 - forward cross-correlation
 +     * 2 - forward residual energy
 +     * 3 - backward cross-correlation
 +     * 4 - backward residual energy
 +     */
 +    int energy[5] = {0, 0, 0, 0, 0};
 +    int16_t *buf  = p->excitation + offset;
 +    int fwd_lag   = autocorr_max(p, offset, &energy[1], pitch_lag,
 +                                 SUBFRAME_LEN, 1);
 +    int back_lag  = autocorr_max(p, offset, &energy[3], pitch_lag,
 +                                 SUBFRAME_LEN, -1);
 +
 +    ppf->index    = 0;
 +    ppf->opt_gain = 0;
 +    ppf->sc_gain  = 0x7fff;
 +
 +    /* Case 0, Section 3.6 */
 +    if (!back_lag && !fwd_lag)
 +        return;
 +
 +    /* Compute target energy */
 +    energy[0] = ff_dot_product(buf, buf, SUBFRAME_LEN)<<1;
 +
 +    /* Compute forward residual energy */
 +    if (fwd_lag)
 +        energy[2] = ff_dot_product(buf + fwd_lag, buf + fwd_lag,
 +                                   SUBFRAME_LEN)<<1;
 +
 +    /* Compute backward residual energy */
 +    if (back_lag)
 +        energy[4] = ff_dot_product(buf - back_lag, buf - back_lag,
 +                                   SUBFRAME_LEN)<<1;
 +
 +    /* Normalize and shorten */
 +    temp1 = 0;
 +    for (i = 0; i < 5; i++)
 +        temp1 = FFMAX(energy[i], temp1);
 +
 +    scale = normalize_bits(temp1, 1);
 +    for (i = 0; i < 5; i++)
 +        energy[i] = av_clipl_int32(energy[i] << scale) >> 16;
 +
 +    if (fwd_lag && !back_lag) {  /* Case 1 */
 +        comp_ppf_gains(fwd_lag,  ppf, cur_rate, energy[0], energy[1],
 +                       energy[2]);
 +    } else if (!fwd_lag) {       /* Case 2 */
 +        comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
 +                       energy[4]);
 +    } else {                     /* Case 3 */
 +
 +        /*
 +         * Select the largest of energy[1]^2/energy[2]
 +         * and energy[3]^2/energy[4]
 +         */
 +        temp1 = energy[4] * ((energy[1] * energy[1] + (1 << 14)) >> 15);
 +        temp2 = energy[2] * ((energy[3] * energy[3] + (1 << 14)) >> 15);
 +        if (temp1 >= temp2) {
 +            comp_ppf_gains(fwd_lag, ppf, cur_rate, energy[0], energy[1],
 +                           energy[2]);
 +        } else {
 +            comp_ppf_gains(-back_lag, ppf, cur_rate, energy[0], energy[3],
 +                           energy[4]);
 +        }
 +    }
 +}
 +
 +/**
 + * Classify frames as voiced/unvoiced.
 + *
 + * @param p         the context
 + * @param pitch_lag decoded pitch_lag
 + * @param exc_eng   excitation energy estimation
 + * @param scale     scaling factor of exc_eng
 + *
 + * @return residual interpolation index if voiced, 0 otherwise
 + */
 +static int comp_interp_index(G723_1_Context *p, int pitch_lag,
 +                             int *exc_eng, int *scale)
 +{
 +    int offset = PITCH_MAX + 2 * SUBFRAME_LEN;
 +    int16_t *buf = p->excitation + offset;
 +
 +    int index, ccr, tgt_eng, best_eng, temp;
 +
 +    *scale = scale_vector(p->excitation, FRAME_LEN + PITCH_MAX);
 +
 +    /* Compute maximum backward cross-correlation */
 +    ccr   = 0;
 +    index = autocorr_max(p, offset, &ccr, pitch_lag, SUBFRAME_LEN * 2, -1);
 +    ccr   = av_clipl_int32((int64_t)ccr + (1 << 15)) >> 16;
 +
 +    /* Compute target energy */
 +    tgt_eng  = ff_dot_product(buf, buf, SUBFRAME_LEN * 2)<<1;
 +    *exc_eng = av_clipl_int32(tgt_eng + (1 << 15)) >> 16;
 +
 +    if (ccr <= 0)
 +        return 0;
 +
 +    /* Compute best energy */
 +    best_eng = ff_dot_product(buf - index, buf - index,
 +                              SUBFRAME_LEN * 2)<<1;
 +    best_eng = av_clipl_int32((int64_t)best_eng + (1 << 15)) >> 16;
 +
 +    temp = best_eng * *exc_eng >> 3;
 +
 +    if (temp < ccr * ccr) {
 +        return index;
 +    } else
 +        return 0;
 +}
 +
 +/**
 + * Peform residual interpolation based on frame classification.
 + *
 + * @param buf   decoded excitation vector
 + * @param out   output vector
 + * @param lag   decoded pitch lag
 + * @param gain  interpolated gain
 + * @param rseed seed for random number generator
 + */
 +static void residual_interp(int16_t *buf, int16_t *out, int lag,
 +                            int gain, int *rseed)
 +{
 +    int i;
 +    if (lag) { /* Voiced */
 +        int16_t *vector_ptr = buf + PITCH_MAX;
 +        /* Attenuate */
 +        for (i = 0; i < lag; i++)
 +            vector_ptr[i - lag] = vector_ptr[i - lag] * 3 >> 2;
 +        av_memcpy_backptr((uint8_t*)vector_ptr, lag * sizeof(int16_t),
 +                          FRAME_LEN * sizeof(int16_t));
 +        memcpy(out, vector_ptr, FRAME_LEN * sizeof(int16_t));
 +    } else {  /* Unvoiced */
 +        for (i = 0; i < FRAME_LEN; i++) {
 +            *rseed = *rseed * 521 + 259;
 +            out[i] = gain * *rseed >> 15;
 +        }
 +        memset(buf, 0, (FRAME_LEN + PITCH_MAX) * sizeof(int16_t));
 +    }
 +}
 +
 +/**
 + * Perform IIR filtering.
 + *
 + * @param fir_coef FIR coefficients
 + * @param iir_coef IIR coefficients
 + * @param src      source vector
 + * @param dest     destination vector
 + * @param width    width of the output, 16 bits(0) / 32 bits(1)
 + */
 +#define iir_filter(fir_coef, iir_coef, src, dest, width)\
 +{\
 +    int m, n;\
 +    int res_shift = 16 & ~-(width);\
 +    int in_shift  = 16 - res_shift;\
 +\
 +    for (m = 0; m < SUBFRAME_LEN; m++) {\
 +        int64_t filter = 0;\
 +        for (n = 1; n <= LPC_ORDER; n++) {\
 +            filter -= (fir_coef)[n - 1] * (src)[m - n] -\
 +                      (iir_coef)[n - 1] * ((dest)[m - n] >> in_shift);\
 +        }\
 +\
 +        (dest)[m] = av_clipl_int32(((src)[m] << 16) + (filter << 3) +\
 +                                   (1 << 15)) >> res_shift;\
 +    }\
 +}
 +
 +/**
 + * Adjust gain of postfiltered signal.
 + *
 + * @param p      the context
 + * @param buf    postfiltered output vector
 + * @param energy input energy coefficient
 + */
 +static void gain_scale(G723_1_Context *p, int16_t * buf, int energy)
 +{
 +    int num, denom, gain, bits1, bits2;
 +    int i;
 +
 +    num   = energy;
 +    denom = 0;
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t temp = buf[i] >> 2;
 +        temp  = av_clipl_int32(MUL64(temp, temp) << 1);
 +        denom = av_clipl_int32(denom + temp);
 +    }
 +
 +    if (num && denom) {
 +        bits1   = normalize_bits(num, 1);
 +        bits2   = normalize_bits(denom, 1);
 +        num     = num << bits1 >> 1;
 +        denom <<= bits2;
 +
 +        bits2 = 5 + bits1 - bits2;
 +        bits2 = FFMAX(0, bits2);
 +
 +        gain = (num >> 1) / (denom >> 16);
 +        gain = square_root(gain << 16 >> bits2);
 +    } else {
 +        gain = 1 << 12;
 +    }
 +
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        p->pf_gain = ((p->pf_gain << 4) - p->pf_gain + gain + (1 << 3)) >> 4;
 +        buf[i]     = av_clip_int16((buf[i] * (p->pf_gain + (p->pf_gain >> 4)) +
 +                                   (1 << 10)) >> 11);
 +    }
 +}
 +
 +/**
 + * Perform formant filtering.
 + *
 + * @param p   the context
 + * @param lpc quantized lpc coefficients
 + * @param buf output buffer
 + */
 +static void formant_postfilter(G723_1_Context *p, int16_t *lpc, int16_t *buf)
 +{
 +    int16_t filter_coef[2][LPC_ORDER], *buf_ptr;
 +    int filter_signal[LPC_ORDER + FRAME_LEN], *signal_ptr;
 +    int i, j, k;
 +
 +    memcpy(buf, p->fir_mem, LPC_ORDER * sizeof(int16_t));
 +    memcpy(filter_signal, p->iir_mem, LPC_ORDER * sizeof(int));
 +
 +    for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {
 +        for (k = 0; k < LPC_ORDER; k++) {
 +            filter_coef[0][k] = (-lpc[k] * postfilter_tbl[0][k] +
 +                                 (1 << 14)) >> 15;
 +            filter_coef[1][k] = (-lpc[k] * postfilter_tbl[1][k] +
 +                                 (1 << 14)) >> 15;
 +        }
 +        iir_filter(filter_coef[0], filter_coef[1], buf + i,
 +                   filter_signal + i, 1);
 +    }
 +
 +    memcpy(p->fir_mem, buf + FRAME_LEN, LPC_ORDER * sizeof(int16_t));
 +    memcpy(p->iir_mem, filter_signal + FRAME_LEN, LPC_ORDER * sizeof(int));
 +
 +    buf_ptr    = buf + LPC_ORDER;
 +    signal_ptr = filter_signal + LPC_ORDER;
 +    for (i = 0; i < SUBFRAMES; i++) {
 +        int16_t temp_vector[SUBFRAME_LEN];
 +        int16_t temp;
 +        int auto_corr[2];
 +        int scale, energy;
 +
 +        /* Normalize */
 +        memcpy(temp_vector, buf_ptr, SUBFRAME_LEN * sizeof(int16_t));
 +        scale = scale_vector(temp_vector, SUBFRAME_LEN);
 +
 +        /* Compute auto correlation coefficients */
 +        auto_corr[0] = ff_dot_product(temp_vector, temp_vector + 1,
 +                                      SUBFRAME_LEN - 1)<<1;
 +        auto_corr[1] = ff_dot_product(temp_vector, temp_vector,
 +                                      SUBFRAME_LEN)<<1;
 +
 +        /* Compute reflection coefficient */
 +        temp = auto_corr[1] >> 16;
 +        if (temp) {
 +            temp = (auto_corr[0] >> 2) / temp;
 +        }
 +        p->reflection_coef = ((p->reflection_coef << 2) - p->reflection_coef +
 +                              temp + 2) >> 2;
 +        temp = (p->reflection_coef * 0xffffc >> 3) & 0xfffc;
 +
 +        /* Compensation filter */
 +        for (j = 0; j < SUBFRAME_LEN; j++) {
 +            buf_ptr[j] = av_clipl_int32(signal_ptr[j] +
 +                                        ((signal_ptr[j - 1] >> 16) *
 +                                         temp << 1)) >> 16;
 +        }
 +
 +        /* Compute normalized signal energy */
 +        temp = 2 * scale + 4;
 +        if (temp < 0) {
 +            energy = av_clipl_int32((int64_t)auto_corr[1] << -temp);
 +        } else
 +            energy = auto_corr[1] >> temp;
 +
 +        gain_scale(p, buf_ptr, energy);
 +
 +        buf_ptr    += SUBFRAME_LEN;
 +        signal_ptr += SUBFRAME_LEN;
 +    }
 +}
 +
 +static int g723_1_decode_frame(AVCodecContext *avctx, void *data,
 +                               int *got_frame_ptr, AVPacket *avpkt)
 +{
 +    G723_1_Context *p  = avctx->priv_data;
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size       = avpkt->size;
 +    int16_t *out;
 +    int dec_mode       = buf[0] & 3;
 +
 +    PPFParam ppf[SUBFRAMES];
 +    int16_t cur_lsp[LPC_ORDER];
 +    int16_t lpc[SUBFRAMES * LPC_ORDER];
 +    int16_t acb_vector[SUBFRAME_LEN];
 +    int16_t *vector_ptr;
 +    int bad_frame = 0, i, j, ret;
 +
 +    if (!buf_size || buf_size < frame_size[dec_mode]) {
 +        *got_frame_ptr = 0;
 +        return buf_size;
 +    }
 +
 +    if (unpack_bitstream(p, buf, buf_size) < 0) {
 +        bad_frame         = 1;
 +        p->cur_frame_type = p->past_frame_type == ActiveFrame ?
 +                            ActiveFrame : UntransmittedFrame;
 +    }
 +
 +    p->frame.nb_samples = FRAME_LEN + LPC_ORDER;
 +    if ((ret = avctx->get_buffer(avctx, &p->frame)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
 +    }
 +    out= (int16_t*)p->frame.data[0];
 +
 +
 +    if(p->cur_frame_type == ActiveFrame) {
 +        if (!bad_frame) {
 +            p->erased_frames = 0;
 +        } else if(p->erased_frames != 3)
 +            p->erased_frames++;
 +
 +        inverse_quant(cur_lsp, p->prev_lsp, p->lsp_index, bad_frame);
 +        lsp_interpolate(lpc, cur_lsp, p->prev_lsp);
 +
 +        /* Save the lsp_vector for the next frame */
 +        memcpy(p->prev_lsp, cur_lsp, LPC_ORDER * sizeof(int16_t));
 +
 +        /* Generate the excitation for the frame */
 +        memcpy(p->excitation, p->prev_excitation, PITCH_MAX * sizeof(int16_t));
 +        vector_ptr = p->excitation + PITCH_MAX;
 +        if (!p->erased_frames) {
 +            /* Update interpolation gain memory */
 +            p->interp_gain = fixed_cb_gain[(p->subframe[2].amp_index +
 +                                            p->subframe[3].amp_index) >> 1];
 +            for (i = 0; i < SUBFRAMES; i++) {
 +                gen_fcb_excitation(vector_ptr, p->subframe[i], p->cur_rate,
 +                                   p->pitch_lag[i >> 1], i);
 +                gen_acb_excitation(acb_vector, &p->excitation[SUBFRAME_LEN * i],
 +                                   p->pitch_lag[i >> 1], p->subframe[i],
 +                                   p->cur_rate);
 +                /* Get the total excitation */
 +                for (j = 0; j < SUBFRAME_LEN; j++) {
 +                    vector_ptr[j] = av_clip_int16(vector_ptr[j] << 1);
 +                    vector_ptr[j] = av_clip_int16(vector_ptr[j] +
 +                                                  acb_vector[j]);
 +                }
 +                vector_ptr += SUBFRAME_LEN;
 +            }
 +
 +            vector_ptr = p->excitation + PITCH_MAX;
 +
 +            /* Save the excitation */
 +            memcpy(out, vector_ptr, FRAME_LEN * sizeof(int16_t));
 +
 +            p->interp_index = comp_interp_index(p, p->pitch_lag[1],
 +                                                &p->sid_gain, &p->cur_gain);
 +
 +            for (i = PITCH_MAX, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
 +                comp_ppf_coeff(p, i, p->pitch_lag[j >> 1],
 +                               ppf + j, p->cur_rate);
 +
 +            /* Restore the original excitation */
 +            memcpy(p->excitation, p->prev_excitation,
 +                   PITCH_MAX * sizeof(int16_t));
 +            memcpy(vector_ptr, out, FRAME_LEN * sizeof(int16_t));
 +
 +            /* Peform pitch postfiltering */
 +            for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
 +                ff_acelp_weighted_vector_sum(out + LPC_ORDER + i, vector_ptr + i,
 +                                             vector_ptr + i + ppf[j].index,
 +                                             ppf[j].sc_gain, ppf[j].opt_gain,
 +                                             1 << 14, 15, SUBFRAME_LEN);
 +        } else {
 +            p->interp_gain = (p->interp_gain * 3 + 2) >> 2;
 +            if (p->erased_frames == 3) {
 +                /* Mute output */
 +                memset(p->excitation, 0,
 +                       (FRAME_LEN + PITCH_MAX) * sizeof(int16_t));
 +                memset(out, 0, (FRAME_LEN + LPC_ORDER) * sizeof(int16_t));
 +            } else {
 +                /* Regenerate frame */
 +                residual_interp(p->excitation, out + LPC_ORDER, p->interp_index,
 +                                p->interp_gain, &p->random_seed);
 +            }
 +        }
 +        /* Save the excitation for the next frame */
 +        memcpy(p->prev_excitation, p->excitation + FRAME_LEN,
 +               PITCH_MAX * sizeof(int16_t));
 +    } else {
 +        memset(out, 0, sizeof(int16_t)*FRAME_LEN);
 +        av_log(avctx, AV_LOG_WARNING,
 +               "G.723.1: Comfort noise generation not supported yet\n");
 +        return frame_size[dec_mode];
 +    }
 +
 +    p->past_frame_type = p->cur_frame_type;
 +
 +    memcpy(out, p->synth_mem, LPC_ORDER * sizeof(int16_t));
 +    for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
 +        ff_celp_lp_synthesis_filter(out + i, &lpc[j * LPC_ORDER],
 +                                    out + i, SUBFRAME_LEN, LPC_ORDER,
 +                                    0, 1, 1 << 12);
 +    memcpy(p->synth_mem, out + FRAME_LEN, LPC_ORDER * sizeof(int16_t));
 +
 +    formant_postfilter(p, lpc, out);
 +
 +    memmove(out, out + LPC_ORDER, sizeof(int16_t)*FRAME_LEN);
 +    p->frame.nb_samples = FRAME_LEN;
 +    *(AVFrame*)data = p->frame;
 +    *got_frame_ptr = 1;
 +
 +    return frame_size[dec_mode];
 +}
 +
 +AVCodec ff_g723_1_decoder = {
 +    .name           = "g723_1",
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = CODEC_ID_G723_1,
 +    .priv_data_size = sizeof(G723_1_Context),
 +    .init           = g723_1_decode_init,
 +    .decode         = g723_1_decode_frame,
 +    .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),
 +    .capabilities   = CODEC_CAP_SUBFRAMES,
 +};
 +
 +#if CONFIG_G723_1_ENCODER
 +#define BITSTREAM_WRITER_LE
 +#include "put_bits.h"
 +
 +static av_cold int g723_1_encode_init(AVCodecContext *avctx)
 +{
 +    G723_1_Context *p = avctx->priv_data;
 +
 +    if (avctx->sample_rate != 8000) {
 +        av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n");
 +        return -1;
 +    }
 +
 +    if (avctx->channels != 1) {
 +        av_log(avctx, AV_LOG_ERROR, "Only mono supported\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (avctx->bit_rate == 6300) {
 +        p->cur_rate = Rate6k3;
 +    } else if (avctx->bit_rate == 5300) {
 +        av_log(avctx, AV_LOG_ERROR, "Bitrate not supported yet, use 6.3k\n");
 +        return AVERROR_PATCHWELCOME;
 +    } else {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "Bitrate not supported, use 6.3k\n");
 +        return AVERROR(EINVAL);
 +    }
 +    avctx->frame_size = 240;
 +    memcpy(p->prev_lsp, dc_lsp, LPC_ORDER * sizeof(int16_t));
 +
 +    return 0;
 +}
 +
 +/**
 + * Remove DC component from the input signal.
 + *
 + * @param buf input signal
 + * @param fir zero memory
 + * @param iir pole memory
 + */
 +static void highpass_filter(int16_t *buf, int16_t *fir, int *iir)
 +{
 +    int i;
 +    for (i = 0; i < FRAME_LEN; i++) {
 +        *iir   = (buf[i] << 15) + ((-*fir) << 15) + MULL2(*iir, 0x7f00);
 +        *fir   = buf[i];
 +        buf[i] = av_clipl_int32((int64_t)*iir + (1 << 15)) >> 16;
 +    }
 +}
 +
 +/**
 + * Estimate autocorrelation of the input vector.
 + *
 + * @param buf      input buffer
 + * @param autocorr autocorrelation coefficients vector
 + */
 +static void comp_autocorr(int16_t *buf, int16_t *autocorr)
 +{
 +    int i, scale, temp;
 +    int16_t vector[LPC_FRAME];
 +
 +    memcpy(vector, buf, LPC_FRAME * sizeof(int16_t));
 +    scale_vector(vector, LPC_FRAME);
 +
 +    /* Apply the Hamming window */
 +    for (i = 0; i < LPC_FRAME; i++)
 +        vector[i] = (vector[i] * hamming_window[i] + (1 << 14)) >> 15;
 +
 +    /* Compute the first autocorrelation coefficient */
 +    temp = dot_product(vector, vector, LPC_FRAME, 0);
 +
 +    /* Apply a white noise correlation factor of (1025/1024) */
 +    temp += temp >> 10;
 +
 +    /* Normalize */
 +    scale = normalize_bits_int32(temp);
 +    autocorr[0] = av_clipl_int32((int64_t)(temp << scale) +
 +                                 (1 << 15)) >> 16;
 +
 +    /* Compute the remaining coefficients */
 +    if (!autocorr[0]) {
 +        memset(autocorr + 1, 0, LPC_ORDER * sizeof(int16_t));
 +    } else {
 +        for (i = 1; i <= LPC_ORDER; i++) {
 +           temp = dot_product(vector, vector + i, LPC_FRAME - i, 0);
 +           temp = MULL2((temp << scale), binomial_window[i - 1]);
 +           autocorr[i] = av_clipl_int32((int64_t)temp + (1 << 15)) >> 16;
 +        }
 +    }
 +}
 +
 +/**
 + * Use Levinson-Durbin recursion to compute LPC coefficients from
 + * autocorrelation values.
 + *
 + * @param lpc      LPC coefficients vector
 + * @param autocorr autocorrelation coefficients vector
 + * @param error    prediction error
 + */
 +static void levinson_durbin(int16_t *lpc, int16_t *autocorr, int16_t error)
 +{
 +    int16_t vector[LPC_ORDER];
 +    int16_t partial_corr;
 +    int i, j, temp;
 +
 +    memset(lpc, 0, LPC_ORDER * sizeof(int16_t));
 +
 +    for (i = 0; i < LPC_ORDER; i++) {
 +        /* Compute the partial correlation coefficient */
 +        temp = 0;
 +        for (j = 0; j < i; j++)
 +            temp -= lpc[j] * autocorr[i - j - 1];
 +        temp = ((autocorr[i] << 13) + temp) << 3;
 +
 +        if (FFABS(temp) >= (error << 16))
 +            break;
 +
 +        partial_corr = temp / (error << 1);
 +
 +        lpc[i] = av_clipl_int32((int64_t)(partial_corr << 14) +
 +                                (1 << 15)) >> 16;
 +
 +        /* Update the prediction error */
 +        temp  = MULL2(temp, partial_corr);
 +        error = av_clipl_int32((int64_t)(error << 16) - temp +
 +                                (1 << 15)) >> 16;
 +
 +        memcpy(vector, lpc, i * sizeof(int16_t));
 +        for (j = 0; j < i; j++) {
 +            temp = partial_corr * vector[i - j - 1] << 1;
 +            lpc[j] = av_clipl_int32((int64_t)(lpc[j] << 16) - temp +
 +                                    (1 << 15)) >> 16;
 +        }
 +    }
 +}
 +
 +/**
 + * Calculate LPC coefficients for the current frame.
 + *
 + * @param buf       current frame
 + * @param prev_data 2 trailing subframes of the previous frame
 + * @param lpc       LPC coefficients vector
 + */
 +static void comp_lpc_coeff(int16_t *buf, int16_t *lpc)
 +{
 +    int16_t autocorr[(LPC_ORDER + 1) * SUBFRAMES];
 +    int16_t *autocorr_ptr = autocorr;
 +    int16_t *lpc_ptr      = lpc;
 +    int i, j;
 +
 +    for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {
 +        comp_autocorr(buf + i, autocorr_ptr);
 +        levinson_durbin(lpc_ptr, autocorr_ptr + 1, autocorr_ptr[0]);
 +
 +        lpc_ptr += LPC_ORDER;
 +        autocorr_ptr += LPC_ORDER + 1;
 +    }
 +}
 +
 +static void lpc2lsp(int16_t *lpc, int16_t *prev_lsp, int16_t *lsp)
 +{
 +    int f[LPC_ORDER + 2]; ///< coefficients of the sum and difference
 +                          ///< polynomials (F1, F2) ordered as
 +                          ///< f1[0], f2[0], ...., f1[5], f2[5]
 +
 +    int max, shift, cur_val, prev_val, count, p;
 +    int i, j;
 +    int64_t temp;
 +
 +    /* Initialize f1[0] and f2[0] to 1 in Q25 */
 +    for (i = 0; i < LPC_ORDER; i++)
 +        lsp[i] = (lpc[i] * bandwidth_expand[i] + (1 << 14)) >> 15;
 +
 +    /* Apply bandwidth expansion on the LPC coefficients */
 +    f[0] = f[1] = 1 << 25;
 +
 +    /* Compute the remaining coefficients */
 +    for (i = 0; i < LPC_ORDER / 2; i++) {
 +        /* f1 */
 +        f[2 * i + 2] = -f[2 * i] - ((lsp[i] + lsp[LPC_ORDER - 1 - i]) << 12);
 +        /* f2 */
 +        f[2 * i + 3] = f[2 * i + 1] - ((lsp[i] - lsp[LPC_ORDER - 1 - i]) << 12);
 +    }
 +
 +    /* Divide f1[5] and f2[5] by 2 for use in polynomial evaluation */
 +    f[LPC_ORDER] >>= 1;
 +    f[LPC_ORDER + 1] >>= 1;
 +
 +    /* Normalize and shorten */
 +    max = FFABS(f[0]);
 +    for (i = 1; i < LPC_ORDER + 2; i++)
 +        max = FFMAX(max, FFABS(f[i]));
 +
 +    shift = normalize_bits_int32(max);
 +
 +    for (i = 0; i < LPC_ORDER + 2; i++)
 +        f[i] = av_clipl_int32((int64_t)(f[i] << shift) + (1 << 15)) >> 16;
 +
 +    /**
 +     * Evaluate F1 and F2 at uniform intervals of pi/256 along the
 +     * unit circle and check for zero crossings.
 +     */
 +    p    = 0;
 +    temp = 0;
 +    for (i = 0; i <= LPC_ORDER / 2; i++)
 +        temp += f[2 * i] * cos_tab[0];
 +    prev_val = av_clipl_int32(temp << 1);
 +    count    = 0;
 +    for ( i = 1; i < COS_TBL_SIZE / 2; i++) {
 +        /* Evaluate */
 +        temp = 0;
 +        for (j = 0; j <= LPC_ORDER / 2; j++)
 +            temp += f[LPC_ORDER - 2 * j + p] * cos_tab[i * j % COS_TBL_SIZE];
 +        cur_val = av_clipl_int32(temp << 1);
 +
 +        /* Check for sign change, indicating a zero crossing */
 +        if ((cur_val ^ prev_val) < 0) {
 +            int abs_cur  = FFABS(cur_val);
 +            int abs_prev = FFABS(prev_val);
 +            int sum      = abs_cur + abs_prev;
 +
 +            shift        = normalize_bits_int32(sum);
 +            sum          <<= shift;
 +            abs_prev     = abs_prev << shift >> 8;
 +            lsp[count++] = ((i - 1) << 7) + (abs_prev >> 1) / (sum >> 16);
 +
 +            if (count == LPC_ORDER)
 +                break;
 +
 +            /* Switch between sum and difference polynomials */
 +            p ^= 1;
 +
 +            /* Evaluate */
 +            temp = 0;
 +            for (j = 0; j <= LPC_ORDER / 2; j++){
 +                temp += f[LPC_ORDER - 2 * j + p] *
 +                        cos_tab[i * j % COS_TBL_SIZE];
 +            }
 +            cur_val = av_clipl_int32(temp<<1);
 +        }
 +        prev_val = cur_val;
 +    }
 +
 +    if (count != LPC_ORDER)
 +        memcpy(lsp, prev_lsp, LPC_ORDER * sizeof(int16_t));
 +}
 +
 +/**
 + * Quantize the current LSP subvector.
 + *
 + * @param num    band number
 + * @param offset offset of the current subvector in an LPC_ORDER vector
 + * @param size   size of the current subvector
 + */
 +#define get_index(num, offset, size) \
 +{\
 +    int error, max = -1;\
 +    int16_t temp[4];\
 +    int i, j;\
 +    for (i = 0; i < LSP_CB_SIZE; i++) {\
 +        for (j = 0; j < size; j++){\
 +            temp[j] = (weight[j + (offset)] * lsp_band##num[i][j] +\
 +                      (1 << 14)) >> 15;\
 +        }\
 +        error =  dot_product(lsp + (offset), temp, size, 1) << 1;\
 +        error -= dot_product(lsp_band##num[i], temp, size, 1);\
 +        if (error > max) {\
 +            max = error;\
 +            lsp_index[num] = i;\
 +        }\
 +    }\
 +}
 +
 +/**
 + * Vector quantize the LSP frequencies.
 + *
 + * @param lsp      the current lsp vector
 + * @param prev_lsp the previous lsp vector
 + */
 +static void lsp_quantize(uint8_t *lsp_index, int16_t *lsp, int16_t *prev_lsp)
 +{
 +    int16_t weight[LPC_ORDER];
 +    int16_t min, max;
 +    int shift, i;
 +
 +    /* Calculate the VQ weighting vector */
 +    weight[0] = (1 << 20) / (lsp[1] - lsp[0]);
 +    weight[LPC_ORDER - 1] = (1 << 20) /
 +                            (lsp[LPC_ORDER - 1] - lsp[LPC_ORDER - 2]);
 +
 +    for (i = 1; i < LPC_ORDER - 1; i++) {
 +        min  = FFMIN(lsp[i] - lsp[i - 1], lsp[i + 1] - lsp[i]);
 +        if (min > 0x20)
 +            weight[i] = (1 << 20) / min;
 +        else
 +            weight[i] = INT16_MAX;
 +    }
 +
 +    /* Normalize */
 +    max = 0;
 +    for (i = 0; i < LPC_ORDER; i++)
 +        max = FFMAX(weight[i], max);
 +
 +    shift = normalize_bits_int16(max);
 +    for (i = 0; i < LPC_ORDER; i++) {
 +        weight[i] <<= shift;
 +    }
 +
 +    /* Compute the VQ target vector */
 +    for (i = 0; i < LPC_ORDER; i++) {
 +        lsp[i] -= dc_lsp[i] +
 +                  (((prev_lsp[i] - dc_lsp[i]) * 12288 + (1 << 14)) >> 15);
 +    }
 +
 +    get_index(0, 0, 3);
 +    get_index(1, 3, 3);
 +    get_index(2, 6, 4);
 +}
 +
 +/**
 + * Apply the formant perceptual weighting filter.
 + *
 + * @param flt_coef filter coefficients
 + * @param unq_lpc  unquantized lpc vector
 + */
 +static void perceptual_filter(G723_1_Context *p, int16_t *flt_coef,
 +                              int16_t *unq_lpc, int16_t *buf)
 +{
 +    int16_t vector[FRAME_LEN + LPC_ORDER];
 +    int i, j, k, l = 0;
 +
 +    memcpy(buf, p->iir_mem, sizeof(int16_t) * LPC_ORDER);
 +    memcpy(vector, p->fir_mem, sizeof(int16_t) * LPC_ORDER);
 +    memcpy(vector + LPC_ORDER, buf + LPC_ORDER, sizeof(int16_t) * FRAME_LEN);
 +
 +    for (i = LPC_ORDER, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++) {
 +        for (k = 0; k < LPC_ORDER; k++) {
 +            flt_coef[k + 2 * l] = (unq_lpc[k + l] * percept_flt_tbl[0][k] +
 +                                  (1 << 14)) >> 15;
 +            flt_coef[k + 2 * l + LPC_ORDER] = (unq_lpc[k + l] *
 +                                             percept_flt_tbl[1][k] +
 +                                             (1 << 14)) >> 15;
 +        }
 +        iir_filter(flt_coef + 2 * l, flt_coef + 2 * l + LPC_ORDER, vector + i,
 +                   buf + i, 0);
 +        l += LPC_ORDER;
 +    }
 +    memcpy(p->iir_mem, buf + FRAME_LEN, sizeof(int16_t) * LPC_ORDER);
 +    memcpy(p->fir_mem, vector + FRAME_LEN, sizeof(int16_t) * LPC_ORDER);
 +}
 +
 +/**
 + * Estimate the open loop pitch period.
 + *
 + * @param buf   perceptually weighted speech
 + * @param start estimation is carried out from this position
 + */
 +static int estimate_pitch(int16_t *buf, int start)
 +{
 +    int max_exp = 32;
 +    int max_ccr = 0x4000;
 +    int max_eng = 0x7fff;
 +    int index   = PITCH_MIN;
 +    int offset  = start - PITCH_MIN + 1;
 +
 +    int ccr, eng, orig_eng, ccr_eng, exp;
 +    int diff, temp;
 +
 +    int i;
 +
 +    orig_eng = dot_product(buf + offset, buf + offset, HALF_FRAME_LEN, 0);
 +
 +    for (i = PITCH_MIN; i <= PITCH_MAX - 3; i++) {
 +        offset--;
 +
 +        /* Update energy and compute correlation */
 +        orig_eng += buf[offset] * buf[offset] -
 +                    buf[offset + HALF_FRAME_LEN] * buf[offset + HALF_FRAME_LEN];
 +        ccr      =  dot_product(buf + start, buf + offset, HALF_FRAME_LEN, 0);
 +        if (ccr <= 0)
 +            continue;
 +
 +        /* Split into mantissa and exponent to maintain precision */
 +        exp  =   normalize_bits_int32(ccr);
 +        ccr  =   av_clipl_int32((int64_t)(ccr << exp) + (1 << 15)) >> 16;
 +        exp  <<= 1;
 +        ccr  *=  ccr;
 +        temp =   normalize_bits_int32(ccr);
 +        ccr  =   ccr << temp >> 16;
 +        exp  +=  temp;
 +
 +        temp =   normalize_bits_int32(orig_eng);
 +        eng  =   av_clipl_int32((int64_t)(orig_eng << temp) + (1 << 15)) >> 16;
 +        exp  -=  temp;
 +
 +        if (ccr >= eng) {
 +            exp--;
 +            ccr >>= 1;
 +        }
 +        if (exp > max_exp)
 +            continue;
 +
 +        if (exp + 1 < max_exp)
 +            goto update;
 +
 +        /* Equalize exponents before comparison */
 +        if (exp + 1 == max_exp)
 +            temp = max_ccr >> 1;
 +        else
 +            temp = max_ccr;
 +        ccr_eng = ccr * max_eng;
 +        diff    = ccr_eng - eng * temp;
 +        if (diff > 0 && (i - index < PITCH_MIN || diff > ccr_eng >> 2)) {
 +update:
 +            index   = i;
 +            max_exp = exp;
 +            max_ccr = ccr;
 +            max_eng = eng;
 +        }
 +    }
 +    return index;
 +}
 +
 +/**
 + * Compute harmonic noise filter parameters.
 + *
 + * @param buf       perceptually weighted speech
 + * @param pitch_lag open loop pitch period
 + * @param hf        harmonic filter parameters
 + */
 +static void comp_harmonic_coeff(int16_t *buf, int16_t pitch_lag, HFParam *hf)
 +{
 +    int ccr, eng, max_ccr, max_eng;
 +    int exp, max, diff;
 +    int energy[15];
 +    int i, j;
 +
 +    for (i = 0, j = pitch_lag - 3; j <= pitch_lag + 3; i++, j++) {
 +        /* Compute residual energy */
 +        energy[i << 1] = dot_product(buf - j, buf - j, SUBFRAME_LEN, 0);
 +        /* Compute correlation */
 +        energy[(i << 1) + 1] = dot_product(buf, buf - j, SUBFRAME_LEN, 0);
 +    }
 +
 +    /* Compute target energy */
 +    energy[14] = dot_product(buf, buf, SUBFRAME_LEN, 0);
 +
 +    /* Normalize */
 +    max = 0;
 +    for (i = 0; i < 15; i++)
 +        max = FFMAX(max, FFABS(energy[i]));
 +
 +    exp = normalize_bits_int32(max);
 +    for (i = 0; i < 15; i++) {
 +        energy[i] = av_clipl_int32((int64_t)(energy[i] << exp) +
 +                                   (1 << 15)) >> 16;
 +    }
 +
 +    hf->index = -1;
 +    hf->gain  =  0;
 +    max_ccr   =  1;
 +    max_eng   =  0x7fff;
 +
 +    for (i = 0; i <= 6; i++) {
 +        eng = energy[i << 1];
 +        ccr = energy[(i << 1) + 1];
 +
 +        if (ccr <= 0)
 +            continue;
 +
 +        ccr  = (ccr * ccr + (1 << 14)) >> 15;
 +        diff = ccr * max_eng - eng * max_ccr;
 +        if (diff > 0) {
 +            max_ccr   = ccr;
 +            max_eng   = eng;
 +            hf->index = i;
 +        }
 +    }
 +
 +    if (hf->index == -1) {
 +        hf->index = pitch_lag;
 +        return;
 +    }
 +
 +    eng = energy[14] * max_eng;
 +    eng = (eng >> 2) + (eng >> 3);
 +    ccr = energy[(hf->index << 1) + 1] * energy[(hf->index << 1) + 1];
 +    if (eng < ccr) {
 +        eng = energy[(hf->index << 1) + 1];
 +
 +        if (eng >= max_eng)
 +            hf->gain = 0x2800;
 +        else
 +            hf->gain = ((eng << 15) / max_eng * 0x2800 + (1 << 14)) >> 15;
 +    }
 +    hf->index += pitch_lag - 3;
 +}
 +
 +/**
 + * Apply the harmonic noise shaping filter.
 + *
 + * @param hf filter parameters
 + */
 +static void harmonic_filter(HFParam *hf, int16_t *src, int16_t *dest)
 +{
 +    int i;
 +
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t temp = hf->gain * src[i - hf->index] << 1;
 +        dest[i] = av_clipl_int32((src[i] << 16) - temp + (1 << 15)) >> 16;
 +    }
 +}
 +
 +static void harmonic_noise_sub(HFParam *hf, int16_t *src, int16_t *dest)
 +{
 +    int i;
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t temp = hf->gain * src[i - hf->index] << 1;
 +        dest[i] = av_clipl_int32(((dest[i] - src[i]) << 16) + temp +
 +                                 (1 << 15)) >> 16;
 +
 +    }
 +}
 +
 +/**
 + * Combined synthesis and formant perceptual weighting filer.
 + *
 + * @param qnt_lpc  quantized lpc coefficients
 + * @param perf_lpc perceptual filter coefficients
 + * @param perf_fir perceptual filter fir memory
 + * @param perf_iir perceptual filter iir memory
 + * @param scale    the filter output will be scaled by 2^scale
 + */
 +static void synth_percept_filter(int16_t *qnt_lpc, int16_t *perf_lpc,
 +                                 int16_t *perf_fir, int16_t *perf_iir,
 +                                 int16_t *src, int16_t *dest, int scale)
 +{
 +    int i, j;
 +    int16_t buf_16[SUBFRAME_LEN + LPC_ORDER];
 +    int64_t buf[SUBFRAME_LEN];
 +
 +    int16_t *bptr_16 = buf_16 + LPC_ORDER;
 +
 +    memcpy(buf_16, perf_fir, sizeof(int16_t) * LPC_ORDER);
 +    memcpy(dest - LPC_ORDER, perf_iir, sizeof(int16_t) * LPC_ORDER);
 +
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t temp = 0;
 +        for (j = 1; j <= LPC_ORDER; j++)
 +            temp -= qnt_lpc[j - 1] * bptr_16[i - j];
 +
 +        buf[i]     = (src[i] << 15) + (temp << 3);
 +        bptr_16[i] = av_clipl_int32(buf[i] + (1 << 15)) >> 16;
 +    }
 +
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t fir = 0, iir = 0;
 +        for (j = 1; j <= LPC_ORDER; j++) {
 +            fir -= perf_lpc[j - 1] * bptr_16[i - j];
 +            iir += perf_lpc[j + LPC_ORDER - 1] * dest[i - j];
 +        }
 +        dest[i] = av_clipl_int32(((buf[i] + (fir << 3)) << scale) + (iir << 3) +
 +                                 (1 << 15)) >> 16;
 +    }
 +    memcpy(perf_fir, buf_16 + SUBFRAME_LEN, sizeof(int16_t) * LPC_ORDER);
 +    memcpy(perf_iir, dest + SUBFRAME_LEN - LPC_ORDER,
 +           sizeof(int16_t) * LPC_ORDER);
 +}
 +
 +/**
 + * Compute the adaptive codebook contribution.
 + *
 + * @param buf   input signal
 + * @param index the current subframe index
 + */
 +static void acb_search(G723_1_Context *p, int16_t *residual,
 +                       int16_t *impulse_resp, int16_t *buf,
 +                       int index)
 +{
 +
 +    int16_t flt_buf[PITCH_ORDER][SUBFRAME_LEN];
 +
 +    const int16_t *cb_tbl = adaptive_cb_gain85;
 +
 +    int ccr_buf[PITCH_ORDER * SUBFRAMES << 2];
 +
 +    int pitch_lag = p->pitch_lag[index >> 1];
 +    int acb_lag   = 1;
 +    int acb_gain  = 0;
 +    int odd_frame = index & 1;
 +    int iter      = 3 + odd_frame;
 +    int count     = 0;
 +    int tbl_size  = 85;
 +
 +    int i, j, k, l, max;
 +    int64_t temp;
 +
 +    if (!odd_frame) {
 +        if (pitch_lag == PITCH_MIN)
 +            pitch_lag++;
 +        else
 +            pitch_lag = FFMIN(pitch_lag, PITCH_MAX - 5);
 +    }
 +
 +    for (i = 0; i < iter; i++) {
 +        get_residual(residual, p->prev_excitation, pitch_lag + i - 1);
 +
 +        for (j = 0; j < SUBFRAME_LEN; j++) {
 +            temp = 0;
 +            for (k = 0; k <= j; k++)
 +                temp += residual[PITCH_ORDER - 1 + k] * impulse_resp[j - k];
 +            flt_buf[PITCH_ORDER - 1][j] = av_clipl_int32((temp << 1) +
 +                                                         (1 << 15)) >> 16;
 +        }
 +
 +        for (j = PITCH_ORDER - 2; j >= 0; j--) {
 +            flt_buf[j][0] = ((residual[j] << 13) + (1 << 14)) >> 15;
 +            for (k = 1; k < SUBFRAME_LEN; k++) {
 +                temp = (flt_buf[j + 1][k - 1] << 15) +
 +                       residual[j] * impulse_resp[k];
 +                flt_buf[j][k] = av_clipl_int32((temp << 1) + (1 << 15)) >> 16;
 +            }
 +        }
 +
 +        /* Compute crosscorrelation with the signal */
 +        for (j = 0; j < PITCH_ORDER; j++) {
 +            temp = dot_product(buf, flt_buf[j], SUBFRAME_LEN, 0);
 +            ccr_buf[count++] = av_clipl_int32(temp << 1);
 +        }
 +
 +        /* Compute energies */
 +        for (j = 0; j < PITCH_ORDER; j++) {
 +            ccr_buf[count++] = dot_product(flt_buf[j], flt_buf[j],
 +                                           SUBFRAME_LEN, 1);
 +        }
 +
 +        for (j = 1; j < PITCH_ORDER; j++) {
 +            for (k = 0; k < j; k++) {
 +                temp = dot_product(flt_buf[j], flt_buf[k], SUBFRAME_LEN, 0);
 +                ccr_buf[count++] = av_clipl_int32(temp<<2);
 +            }
 +        }
 +    }
 +
 +    /* Normalize and shorten */
 +    max = 0;
 +    for (i = 0; i < 20 * iter; i++)
 +        max = FFMAX(max, FFABS(ccr_buf[i]));
 +
 +    temp = normalize_bits_int32(max);
 +
 +    for (i = 0; i < 20 * iter; i++){
 +        ccr_buf[i] = av_clipl_int32((int64_t)(ccr_buf[i] << temp) +
 +                                    (1 << 15)) >> 16;
 +    }
 +
 +    max = 0;
 +    for (i = 0; i < iter; i++) {
 +        /* Select quantization table */
 +        if (!odd_frame && pitch_lag + i - 1 >= SUBFRAME_LEN - 2 ||
 +            odd_frame && pitch_lag >= SUBFRAME_LEN - 2) {
 +            cb_tbl = adaptive_cb_gain170;
 +            tbl_size = 170;
 +        }
 +
 +        for (j = 0, k = 0; j < tbl_size; j++, k += 20) {
 +            temp = 0;
 +            for (l = 0; l < 20; l++)
 +                temp += ccr_buf[20 * i + l] * cb_tbl[k + l];
 +            temp =  av_clipl_int32(temp);
 +
 +            if (temp > max) {
 +                max      = temp;
 +                acb_gain = j;
 +                acb_lag  = i;
 +            }
 +        }
 +    }
 +
 +    if (!odd_frame) {
 +        pitch_lag += acb_lag - 1;
 +        acb_lag   =  1;
 +    }
 +
 +    p->pitch_lag[index >> 1]      = pitch_lag;
 +    p->subframe[index].ad_cb_lag  = acb_lag;
 +    p->subframe[index].ad_cb_gain = acb_gain;
 +}
 +
 +/**
 + * Subtract the adaptive codebook contribution from the input
 + * to obtain the residual.
 + *
 + * @param buf target vector
 + */
 +static void sub_acb_contrib(int16_t *residual, int16_t *impulse_resp,
 +                            int16_t *buf)
 +{
 +    int i, j;
 +    /* Subtract adaptive CB contribution to obtain the residual */
 +    for (i = 0; i < SUBFRAME_LEN; i++) {
 +        int64_t temp = buf[i] << 14;
 +        for (j = 0; j <= i; j++)
 +            temp -= residual[j] * impulse_resp[i - j];
 +
 +        buf[i] = av_clipl_int32((temp << 2) + (1 << 15)) >> 16;
 +    }
 +}
 +
 +/**
 + * Quantize the residual signal using the fixed codebook (MP-MLQ).
 + *
 + * @param optim optimized fixed codebook parameters
 + * @param buf   excitation vector
 + */
 +static void get_fcb_param(FCBParam *optim, int16_t *impulse_resp,
 +                          int16_t *buf, int pulse_cnt, int pitch_lag)
 +{
 +    FCBParam param;
 +    int16_t impulse_r[SUBFRAME_LEN];
 +    int16_t temp_corr[SUBFRAME_LEN];
 +    int16_t impulse_corr[SUBFRAME_LEN];
 +
 +    int ccr1[SUBFRAME_LEN];
 +    int ccr2[SUBFRAME_LEN];
 +    int amp, err, max, max_amp_index, min, scale, i, j, k, l;
 +
 +    int64_t temp;
 +
 +    /* Update impulse response */
 +    memcpy(impulse_r, impulse_resp, sizeof(int16_t) * SUBFRAME_LEN);
 +    param.dirac_train = 0;
 +    if (pitch_lag < SUBFRAME_LEN - 2) {
 +        param.dirac_train = 1;
 +        gen_dirac_train(impulse_r, pitch_lag);
 +    }
 +
 +    for (i = 0; i < SUBFRAME_LEN; i++)
 +        temp_corr[i] = impulse_r[i] >> 1;
 +
 +    /* Compute impulse response autocorrelation */
 +    temp = dot_product(temp_corr, temp_corr, SUBFRAME_LEN, 1);
 +
 +    scale = normalize_bits_int32(temp);
 +    impulse_corr[0] = av_clipl_int32((temp << scale) + (1 << 15)) >> 16;
 +
 +    for (i = 1; i < SUBFRAME_LEN; i++) {
 +        temp = dot_product(temp_corr + i, temp_corr, SUBFRAME_LEN - i, 1);
 +        impulse_corr[i] = av_clipl_int32((temp << scale) + (1 << 15)) >> 16;
 +    }
 +
 +    /* Compute crosscorrelation of impulse response with residual signal */
 +    scale -= 4;
 +    for (i = 0; i < SUBFRAME_LEN; i++){
 +        temp = dot_product(buf + i, impulse_r, SUBFRAME_LEN - i, 1);
 +        if (scale < 0)
 +            ccr1[i] = temp >> -scale;
 +        else
 +            ccr1[i] = av_clipl_int32(temp << scale);
 +    }
 +
 +    /* Search loop */
 +    for (i = 0; i < GRID_SIZE; i++) {
 +        /* Maximize the crosscorrelation */
 +        max = 0;
 +        for (j = i; j < SUBFRAME_LEN; j += GRID_SIZE) {
 +            temp = FFABS(ccr1[j]);
 +            if (temp >= max) {
 +                max = temp;
 +                param.pulse_pos[0] = j;
 +            }
 +        }
 +
 +        /* Quantize the gain (max crosscorrelation/impulse_corr[0]) */
 +        amp = max;
 +        min = 1 << 30;
 +        max_amp_index = GAIN_LEVELS - 2;
 +        for (j = max_amp_index; j >= 2; j--) {
 +            temp = av_clipl_int32((int64_t)fixed_cb_gain[j] *
 +                                  impulse_corr[0] << 1);
 +            temp = FFABS(temp - amp);
 +            if (temp < min) {
 +                min = temp;
 +                max_amp_index = j;
 +            }
 +        }
 +
 +        max_amp_index--;
 +        /* Select additional gain values */
 +        for (j = 1; j < 5; j++) {
 +            for (k = i; k < SUBFRAME_LEN; k += GRID_SIZE) {
 +                temp_corr[k] = 0;
 +                ccr2[k]      = ccr1[k];
 +            }
 +            param.amp_index = max_amp_index + j - 2;
 +            amp = fixed_cb_gain[param.amp_index];
 +
 +            param.pulse_sign[0] = (ccr2[param.pulse_pos[0]] < 0) ? -amp : amp;
 +            temp_corr[param.pulse_pos[0]] = 1;
 +
 +            for (k = 1; k < pulse_cnt; k++) {
 +                max = -1 << 30;
 +                for (l = i; l < SUBFRAME_LEN; l += GRID_SIZE) {
 +                    if (temp_corr[l])
 +                        continue;
 +                    temp = impulse_corr[FFABS(l - param.pulse_pos[k - 1])];
 +                    temp = av_clipl_int32((int64_t)temp *
 +                                          param.pulse_sign[k - 1] << 1);
 +                    ccr2[l] -= temp;
 +                    temp = FFABS(ccr2[l]);
 +                    if (temp > max) {
 +                        max = temp;
 +                        param.pulse_pos[k] = l;
 +                    }
 +                }
 +
 +                param.pulse_sign[k] = (ccr2[param.pulse_pos[k]] < 0) ?
 +                                      -amp : amp;
 +                temp_corr[param.pulse_pos[k]] = 1;
 +            }
 +
 +            /* Create the error vector */
 +            memset(temp_corr, 0, sizeof(int16_t) * SUBFRAME_LEN);
 +
 +            for (k = 0; k < pulse_cnt; k++)
 +                temp_corr[param.pulse_pos[k]] = param.pulse_sign[k];
 +
 +            for (k = SUBFRAME_LEN - 1; k >= 0; k--) {
 +                temp = 0;
 +                for (l = 0; l <= k; l++) {
 +                    int prod = av_clipl_int32((int64_t)temp_corr[l] *
 +                                              impulse_r[k - l] << 1);
 +                    temp     = av_clipl_int32(temp + prod);
 +                }
 +                temp_corr[k] = temp << 2 >> 16;
 +            }
 +
 +            /* Compute square of error */
 +            err = 0;
 +            for (k = 0; k < SUBFRAME_LEN; k++) {
 +                int64_t prod;
 +                prod = av_clipl_int32((int64_t)buf[k] * temp_corr[k] << 1);
 +                err  = av_clipl_int32(err - prod);
 +                prod = av_clipl_int32((int64_t)temp_corr[k] * temp_corr[k]);
 +                err  = av_clipl_int32(err + prod);
 +            }
 +
 +            /* Minimize */
 +            if (err < optim->min_err) {
 +                optim->min_err     = err;
 +                optim->grid_index  = i;
 +                optim->amp_index   = param.amp_index;
 +                optim->dirac_train = param.dirac_train;
 +
 +                for (k = 0; k < pulse_cnt; k++) {
 +                    optim->pulse_sign[k] = param.pulse_sign[k];
 +                    optim->pulse_pos[k]  = param.pulse_pos[k];
 +                }
 +            }
 +        }
 +    }
 +}
 +
 +/**
 + * Encode the pulse position and gain of the current subframe.
 + *
 + * @param optim optimized fixed CB parameters
 + * @param buf   excitation vector
 + */
 +static void pack_fcb_param(G723_1_Subframe *subfrm, FCBParam *optim,
 +                           int16_t *buf, int pulse_cnt)
 +{
 +    int i, j;
 +
 +    j = PULSE_MAX - pulse_cnt;
 +
 +    subfrm->pulse_sign = 0;
 +    subfrm->pulse_pos  = 0;
 +
 +    for (i = 0; i < SUBFRAME_LEN >> 1; i++) {
 +        int val = buf[optim->grid_index + (i << 1)];
 +        if (!val) {
 +            subfrm->pulse_pos += combinatorial_table[j][i];
 +        } else {
 +            subfrm->pulse_sign <<= 1;
 +            if (val < 0) subfrm->pulse_sign++;
 +            j++;
 +
 +            if (j == PULSE_MAX) break;
 +        }
 +    }
 +    subfrm->amp_index   = optim->amp_index;
 +    subfrm->grid_index  = optim->grid_index;
 +    subfrm->dirac_train = optim->dirac_train;
 +}
 +
 +/**
 + * Compute the fixed codebook excitation.
 + *
 + * @param buf          target vector
 + * @param impulse_resp impulse response of the combined filter
 + */
 +static void fcb_search(G723_1_Context *p, int16_t *impulse_resp,
 +                       int16_t *buf, int index)
 +{
 +    FCBParam optim;
 +    int pulse_cnt = pulses[index];
 +    int i;
 +
 +    optim.min_err = 1 << 30;
 +    get_fcb_param(&optim, impulse_resp, buf, pulse_cnt, SUBFRAME_LEN);
 +
 +    if (p->pitch_lag[index >> 1] < SUBFRAME_LEN - 2) {
 +        get_fcb_param(&optim, impulse_resp, buf, pulse_cnt,
 +                      p->pitch_lag[index >> 1]);
 +    }
 +
 +    /* Reconstruct the excitation */
 +    memset(buf, 0, sizeof(int16_t) * SUBFRAME_LEN);
 +    for (i = 0; i < pulse_cnt; i++)
 +        buf[optim.pulse_pos[i]] = optim.pulse_sign[i];
 +
 +    pack_fcb_param(&p->subframe[index], &optim, buf, pulse_cnt);
 +
 +    if (optim.dirac_train)
 +        gen_dirac_train(buf, p->pitch_lag[index >> 1]);
 +}
 +
 +/**
 + * Pack the frame parameters into output bitstream.
 + *
 + * @param frame output buffer
 + * @param size  size of the buffer
 + */
 +static int pack_bitstream(G723_1_Context *p, unsigned char *frame, int size)
 +{
 +    PutBitContext pb;
 +    int info_bits, i, temp;
 +
 +    init_put_bits(&pb, frame, size);
 +
 +    if (p->cur_rate == Rate6k3) {
 +        info_bits = 0;
 +        put_bits(&pb, 2, info_bits);
 +    }
 +
 +    put_bits(&pb, 8, p->lsp_index[2]);
 +    put_bits(&pb, 8, p->lsp_index[1]);
 +    put_bits(&pb, 8, p->lsp_index[0]);
 +
 +    put_bits(&pb, 7, p->pitch_lag[0] - PITCH_MIN);
 +    put_bits(&pb, 2, p->subframe[1].ad_cb_lag);
 +    put_bits(&pb, 7, p->pitch_lag[1] - PITCH_MIN);
 +    put_bits(&pb, 2, p->subframe[3].ad_cb_lag);
 +
 +    /* Write 12 bit combined gain */
 +    for (i = 0; i < SUBFRAMES; i++) {
 +        temp = p->subframe[i].ad_cb_gain * GAIN_LEVELS +
 +               p->subframe[i].amp_index;
 +        if (p->cur_rate ==  Rate6k3)
 +            temp += p->subframe[i].dirac_train << 11;
 +        put_bits(&pb, 12, temp);
 +    }
 +
 +    put_bits(&pb, 1, p->subframe[0].grid_index);
 +    put_bits(&pb, 1, p->subframe[1].grid_index);
 +    put_bits(&pb, 1, p->subframe[2].grid_index);
 +    put_bits(&pb, 1, p->subframe[3].grid_index);
 +
 +    if (p->cur_rate == Rate6k3) {
 +        skip_put_bits(&pb, 1); /* reserved bit */
 +
 +        /* Write 13 bit combined position index */
 +        temp = (p->subframe[0].pulse_pos >> 16) * 810 +
 +               (p->subframe[1].pulse_pos >> 14) *  90 +
 +               (p->subframe[2].pulse_pos >> 16) *   9 +
 +               (p->subframe[3].pulse_pos >> 14);
 +        put_bits(&pb, 13, temp);
 +
 +        put_bits(&pb, 16, p->subframe[0].pulse_pos & 0xffff);
 +        put_bits(&pb, 14, p->subframe[1].pulse_pos & 0x3fff);
 +        put_bits(&pb, 16, p->subframe[2].pulse_pos & 0xffff);
 +        put_bits(&pb, 14, p->subframe[3].pulse_pos & 0x3fff);
 +
 +        put_bits(&pb, 6, p->subframe[0].pulse_sign);
 +        put_bits(&pb, 5, p->subframe[1].pulse_sign);
 +        put_bits(&pb, 6, p->subframe[2].pulse_sign);
 +        put_bits(&pb, 5, p->subframe[3].pulse_sign);
 +    }
 +
 +    flush_put_bits(&pb);
 +    return frame_size[info_bits];
 +}
 +
 +static int g723_1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
 +                               int buf_size, void *data)
 +{
 +    G723_1_Context *p = avctx->priv_data;
 +    int16_t unq_lpc[LPC_ORDER * SUBFRAMES];
 +    int16_t qnt_lpc[LPC_ORDER * SUBFRAMES];
 +    int16_t cur_lsp[LPC_ORDER];
 +    int16_t weighted_lpc[LPC_ORDER * SUBFRAMES << 1];
 +    int16_t vector[FRAME_LEN + PITCH_MAX];
 +    int offset;
 +    int16_t *in = data;
 +
 +    HFParam hf[4];
 +    int i, j;
 +
 +    highpass_filter(in, &p->hpf_fir_mem, &p->hpf_iir_mem);
 +
 +    memcpy(vector, p->prev_data, HALF_FRAME_LEN * sizeof(int16_t));
 +    memcpy(vector + HALF_FRAME_LEN, in, FRAME_LEN * sizeof(int16_t));
 +
 +    comp_lpc_coeff(vector, unq_lpc);
 +    lpc2lsp(&unq_lpc[LPC_ORDER * 3], p->prev_lsp, cur_lsp);
 +    lsp_quantize(p->lsp_index, cur_lsp, p->prev_lsp);
 +
 +    /* Update memory */
 +    memcpy(vector + LPC_ORDER, p->prev_data + SUBFRAME_LEN,
 +           sizeof(int16_t) * SUBFRAME_LEN);
 +    memcpy(vector + LPC_ORDER + SUBFRAME_LEN, in,
 +           sizeof(int16_t) * (HALF_FRAME_LEN + SUBFRAME_LEN));
 +    memcpy(p->prev_data, in + HALF_FRAME_LEN,
 +           sizeof(int16_t) * HALF_FRAME_LEN);
 +    memcpy(in, vector + LPC_ORDER, sizeof(int16_t) * FRAME_LEN);
 +
 +    perceptual_filter(p, weighted_lpc, unq_lpc, vector);
 +
 +    memcpy(in, vector + LPC_ORDER, sizeof(int16_t) * FRAME_LEN);
 +    memcpy(vector, p->prev_weight_sig, sizeof(int16_t) * PITCH_MAX);
 +    memcpy(vector + PITCH_MAX, in, sizeof(int16_t) * FRAME_LEN);
 +
 +    scale_vector(vector, FRAME_LEN + PITCH_MAX);
 +
 +    p->pitch_lag[0] = estimate_pitch(vector, PITCH_MAX);
 +    p->pitch_lag[1] = estimate_pitch(vector, PITCH_MAX + HALF_FRAME_LEN);
 +
 +    for (i = PITCH_MAX, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
 +        comp_harmonic_coeff(vector + i, p->pitch_lag[j >> 1], hf + j);
 +
 +    memcpy(vector, p->prev_weight_sig, sizeof(int16_t) * PITCH_MAX);
 +    memcpy(vector + PITCH_MAX, in, sizeof(int16_t) * FRAME_LEN);
 +    memcpy(p->prev_weight_sig, vector + FRAME_LEN, sizeof(int16_t) * PITCH_MAX);
 +
 +    for (i = 0, j = 0; j < SUBFRAMES; i += SUBFRAME_LEN, j++)
 +        harmonic_filter(hf + j, vector + PITCH_MAX + i, in + i);
 +
 +    inverse_quant(cur_lsp, p->prev_lsp, p->lsp_index, 0);
 +    lsp_interpolate(qnt_lpc, cur_lsp, p->prev_lsp);
 +
 +    memcpy(p->prev_lsp, cur_lsp, sizeof(int16_t) * LPC_ORDER);
 +
 +    offset = 0;
 +    for (i = 0; i < SUBFRAMES; i++) {
 +        int16_t impulse_resp[SUBFRAME_LEN];
 +        int16_t residual[SUBFRAME_LEN + PITCH_ORDER - 1];
 +        int16_t flt_in[SUBFRAME_LEN];
 +        int16_t zero[LPC_ORDER], fir[LPC_ORDER], iir[LPC_ORDER];
 +
 +        /**
 +         * Compute the combined impulse response of the synthesis filter,
 +         * formant perceptual weighting filter and harmonic noise shaping filter
 +         */
 +        memset(zero, 0, sizeof(int16_t) * LPC_ORDER);
 +        memset(vector, 0, sizeof(int16_t) * PITCH_MAX);
 +        memset(flt_in, 0, sizeof(int16_t) * SUBFRAME_LEN);
 +
 +        flt_in[0] = 1 << 13; /* Unit impulse */
 +        synth_percept_filter(qnt_lpc + offset, weighted_lpc + (offset << 1),
 +                             zero, zero, flt_in, vector + PITCH_MAX, 1);
 +        harmonic_filter(hf + i, vector + PITCH_MAX, impulse_resp);
 +
 +         /* Compute the combined zero input response */
 +        flt_in[0] = 0;
 +        memcpy(fir, p->perf_fir_mem, sizeof(int16_t) * LPC_ORDER);
 +        memcpy(iir, p->perf_iir_mem, sizeof(int16_t) * LPC_ORDER);
 +
 +        synth_percept_filter(qnt_lpc + offset, weighted_lpc + (offset << 1),
 +                             fir, iir, flt_in, vector + PITCH_MAX, 0);
 +        memcpy(vector, p->harmonic_mem, sizeof(int16_t) * PITCH_MAX);
 +        harmonic_noise_sub(hf + i, vector + PITCH_MAX, in);
 +
 +        acb_search(p, residual, impulse_resp, in, i);
 +        gen_acb_excitation(residual, p->prev_excitation,p->pitch_lag[i >> 1],
 +                           p->subframe[i], p->cur_rate);
 +        sub_acb_contrib(residual, impulse_resp, in);
 +
 +        fcb_search(p, impulse_resp, in, i);
 +
 +        /* Reconstruct the excitation */
 +        gen_acb_excitation(impulse_resp, p->prev_excitation, p->pitch_lag[i >> 1],
 +                           p->subframe[i], Rate6k3);
 +
 +        memmove(p->prev_excitation, p->prev_excitation + SUBFRAME_LEN,
 +               sizeof(int16_t) * (PITCH_MAX - SUBFRAME_LEN));
 +        for (j = 0; j < SUBFRAME_LEN; j++)
 +            in[j] = av_clip_int16((in[j] << 1) + impulse_resp[j]);
 +        memcpy(p->prev_excitation + PITCH_MAX - SUBFRAME_LEN, in,
 +               sizeof(int16_t) * SUBFRAME_LEN);
 +
 +        /* Update filter memories */
 +        synth_percept_filter(qnt_lpc + offset, weighted_lpc + (offset << 1),
 +                             p->perf_fir_mem, p->perf_iir_mem,
 +                             in, vector + PITCH_MAX, 0);
 +        memmove(p->harmonic_mem, p->harmonic_mem + SUBFRAME_LEN,
 +                sizeof(int16_t) * (PITCH_MAX - SUBFRAME_LEN));
 +        memcpy(p->harmonic_mem + PITCH_MAX - SUBFRAME_LEN, vector + PITCH_MAX,
 +               sizeof(int16_t) * SUBFRAME_LEN);
 +
 +        in += SUBFRAME_LEN;
 +        offset += LPC_ORDER;
 +    }
 +
 +    return pack_bitstream(p, buf, buf_size);
 +}
 +
 +AVCodec ff_g723_1_encoder = {
 +    .name           = "g723_1",
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = CODEC_ID_G723_1,
 +    .priv_data_size = sizeof(G723_1_Context),
 +    .init           = g723_1_encode_init,
 +    .encode         = g723_1_encode_frame,
 +    .long_name      = NULL_IF_CONFIG_SMALL("G.723.1"),
++    .sample_fmts    = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
++                                                    AV_SAMPLE_FMT_NONE},
 +};
 +#endif
@@@ -3694,8 -3661,7 +3694,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) {
++                       || get_bits_count(&s->gb) <  s->gb.size_in_bits && !(s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
                          ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END&part_mask);
  
                          return 0;
Simple merge
index 75b792d,0000000..fd01f0a
mode 100644,000000..100644
--- /dev/null
@@@ -1,134 -1,0 +1,134 @@@
-     .sample_fmts = (const enum SampleFormat[]){AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
 +/*
 + * Interface to libaacplus for aac+ (sbr+ps) encoding
 + * Copyright (c) 2010 tipok <piratfm@gmail.com>
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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
 + */
 +
 +/**
 + * @file
 + * Interface to libaacplus for aac+ (sbr+ps) encoding.
 + */
 +
 +#include "avcodec.h"
 +#include <aacplus.h>
 +
 +typedef struct aacPlusAudioContext {
 +    aacplusEncHandle aacplus_handle;
 +} aacPlusAudioContext;
 +
 +static av_cold int aacPlus_encode_init(AVCodecContext *avctx)
 +{
 +    aacPlusAudioContext *s = avctx->priv_data;
 +    aacplusEncConfiguration *aacplus_cfg;
 +    unsigned long samples_input, max_bytes_output;
 +
 +    /* number of channels */
 +    if (avctx->channels < 1 || avctx->channels > 2) {
 +        av_log(avctx, AV_LOG_ERROR, "encoding %d channel(s) is not allowed\n", avctx->channels);
 +        return -1;
 +    }
 +
 +    s->aacplus_handle = aacplusEncOpen(avctx->sample_rate,
 +                                 avctx->channels,
 +                                 &samples_input, &max_bytes_output);
 +    if(!s->aacplus_handle) {
 +            av_log(avctx, AV_LOG_ERROR, "can't open encoder\n");
 +            return -1;
 +    }
 +
 +    /* check aacplus version */
 +    aacplus_cfg = aacplusEncGetCurrentConfiguration(s->aacplus_handle);
 +
 +    /* put the options in the configuration struct */
 +    if(avctx->profile != FF_PROFILE_AAC_LOW && avctx->profile != FF_PROFILE_UNKNOWN) {
 +            av_log(avctx, AV_LOG_ERROR, "invalid AAC profile: %d, only LC supported\n", avctx->profile);
 +            aacplusEncClose(s->aacplus_handle);
 +            return -1;
 +    }
 +
 +    aacplus_cfg->bitRate = avctx->bit_rate;
 +    aacplus_cfg->bandWidth = avctx->cutoff;
 +    aacplus_cfg->outputFormat = !(avctx->flags & CODEC_FLAG_GLOBAL_HEADER);
 +    aacplus_cfg->inputFormat = AACPLUS_INPUT_16BIT;
 +    if (!aacplusEncSetConfiguration(s->aacplus_handle, aacplus_cfg)) {
 +        av_log(avctx, AV_LOG_ERROR, "libaacplus doesn't support this output format!\n");
 +        return -1;
 +    }
 +
 +    avctx->frame_size = samples_input / avctx->channels;
 +
 +    avctx->coded_frame= avcodec_alloc_frame();
 +    avctx->coded_frame->key_frame= 1;
 +
 +    /* Set decoder specific info */
 +    avctx->extradata_size = 0;
 +    if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER) {
 +
 +        unsigned char *buffer = NULL;
 +        unsigned long decoder_specific_info_size;
 +
 +        if (aacplusEncGetDecoderSpecificInfo(s->aacplus_handle, &buffer,
 +                                           &decoder_specific_info_size) == 1) {
 +            avctx->extradata = av_malloc(decoder_specific_info_size + FF_INPUT_BUFFER_PADDING_SIZE);
 +            avctx->extradata_size = decoder_specific_info_size;
 +            memcpy(avctx->extradata, buffer, avctx->extradata_size);
 +        }
 +#undef free
 +        free(buffer);
 +#define free please_use_av_free
 +    }
 +    return 0;
 +}
 +
 +static int aacPlus_encode_frame(AVCodecContext *avctx,
 +                             unsigned char *frame, int buf_size, void *data)
 +{
 +    aacPlusAudioContext *s = avctx->priv_data;
 +    int bytes_written;
 +
 +    bytes_written = aacplusEncEncode(s->aacplus_handle,
 +                                  data,
 +                                  avctx->frame_size * avctx->channels,
 +                                  frame,
 +                                  buf_size);
 +
 +    return bytes_written;
 +}
 +
 +static av_cold int aacPlus_encode_close(AVCodecContext *avctx)
 +{
 +    aacPlusAudioContext *s = avctx->priv_data;
 +
 +    av_freep(&avctx->coded_frame);
 +    av_freep(&avctx->extradata);
 +
 +    aacplusEncClose(s->aacplus_handle);
 +    return 0;
 +}
 +
 +AVCodec ff_libaacplus_encoder = {
 +    .name           = "libaacplus",
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = CODEC_ID_AAC,
 +    .priv_data_size = sizeof(aacPlusAudioContext),
 +    .init           = aacPlus_encode_init,
 +    .encode         = aacPlus_encode_frame,
 +    .close          = aacPlus_encode_close,
++    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_NONE},
 +    .long_name = NULL_IF_CONFIG_SMALL("libaacplus AAC+ (Advanced Audio Codec with SBR+PS)"),
 +};
Simple merge
Simple merge
@@@ -345,70 -264,10 +334,21 @@@ static av_cold int X264_init(AVCodecCon
              (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
      }
  
 -    x4->params.rc.f_ip_factor             = 1 / fabs(avctx->i_quant_factor);
 -    x4->params.rc.f_pb_factor             = avctx->b_quant_factor;
 -    x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
 +    OPT_STR("level", x4->level);
 +
 +    if(x4->x264opts){
 +        const char *p= x4->x264opts;
 +        while(p){
 +            char param[256]={0}, val[256]={0};
 +            if(sscanf(p, "%255[^:=]=%255[^:]", param, val) == 1){
 +                OPT_STR(param, "1");
 +            }else
 +                OPT_STR(param, val);
 +            p= strchr(p, ':');
 +            p+=!!p;
 +        }
 +    }
  
- #if FF_API_X264_GLOBAL_OPTS
-     if (avctx->aq_mode >= 0)
-         x4->params.rc.i_aq_mode = avctx->aq_mode;
-     if (avctx->aq_strength >= 0)
-         x4->params.rc.f_aq_strength = avctx->aq_strength;
-     if (avctx->psy_rd >= 0)
-         x4->params.analyse.f_psy_rd           = avctx->psy_rd;
-     if (avctx->psy_trellis >= 0)
-         x4->params.analyse.f_psy_trellis      = avctx->psy_trellis;
-     if (avctx->rc_lookahead >= 0)
-         x4->params.rc.i_lookahead             = avctx->rc_lookahead;
-     if (avctx->weighted_p_pred >= 0)
-         x4->params.analyse.i_weighted_pred    = avctx->weighted_p_pred;
-     if (avctx->bframebias)
-         x4->params.i_bframe_bias              = avctx->bframebias;
-     if (avctx->deblockalpha)
-         x4->params.i_deblocking_filter_alphac0 = avctx->deblockalpha;
-     if (avctx->deblockbeta)
-         x4->params.i_deblocking_filter_beta    = avctx->deblockbeta;
-     if (avctx->complexityblur >= 0)
-         x4->params.rc.f_complexity_blur        = avctx->complexityblur;
-     if (avctx->directpred >= 0)
-         x4->params.analyse.i_direct_mv_pred    = avctx->directpred;
-     if (avctx->partitions) {
-         if (avctx->partitions & X264_PART_I4X4)
-             x4->params.analyse.inter |= X264_ANALYSE_I4x4;
-         if (avctx->partitions & X264_PART_I8X8)
-             x4->params.analyse.inter |= X264_ANALYSE_I8x8;
-         if (avctx->partitions & X264_PART_P8X8)
-             x4->params.analyse.inter |= X264_ANALYSE_PSUB16x16;
-         if (avctx->partitions & X264_PART_P4X4)
-             x4->params.analyse.inter |= X264_ANALYSE_PSUB8x8;
-         if (avctx->partitions & X264_PART_B8X8)
-             x4->params.analyse.inter |= X264_ANALYSE_BSUB16x16;
-     }
-     if (avctx->flags2) {
-         x4->params.analyse.b_ssim = avctx->flags2 & CODEC_FLAG2_SSIM;
-         x4->params.b_intra_refresh = avctx->flags2 & CODEC_FLAG2_INTRA_REFRESH;
-         x4->params.i_bframe_pyramid = avctx->flags2 & CODEC_FLAG2_BPYRAMID ? X264_B_PYRAMID_NORMAL : X264_B_PYRAMID_NONE;
-         x4->params.analyse.b_weighted_bipred  = avctx->flags2 & CODEC_FLAG2_WPRED;
-         x4->params.analyse.b_mixed_references = avctx->flags2 & CODEC_FLAG2_MIXED_REFS;
-         x4->params.analyse.b_transform_8x8    = avctx->flags2 & CODEC_FLAG2_8X8DCT;
-         x4->params.analyse.b_fast_pskip       = avctx->flags2 & CODEC_FLAG2_FASTPSKIP;
-         x4->params.b_aud                      = avctx->flags2 & CODEC_FLAG2_AUD;
-         x4->params.analyse.b_psy              = avctx->flags2 & CODEC_FLAG2_PSY;
-         x4->params.rc.b_mb_tree               = !!(avctx->flags2 & CODEC_FLAG2_MBTREE);
-     }
- #endif
      if (avctx->me_method == ME_EPZS)
          x4->params.analyse.i_me_method = X264_ME_DIA;
      else if (avctx->me_method == ME_HEX)
@@@ -675,7 -511,6 +612,7 @@@ static const AVCodecDefault x264_defaul
      { "qdiff",            "-1" },
      { "qblur",            "-1" },
      { "qcomp",            "-1" },
-     { "rc_lookahead",     "-1" },
++//     { "rc_lookahead",     "-1" },
      { "refs",             "-1" },
      { "sc_threshold",     "-1" },
      { "trellis",          "-1" },
Simple merge
Simple merge
Simple merge
Simple merge
  
          /* per-MB end of slice check */
      if(s->codec_id==CODEC_ID_MPEG4){
 -        if(mpeg4_is_resync(s)){
 -            const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
 +        int next= mpeg4_is_resync(s);
 +        if(next) {
-             if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && s->avctx->error_recognition >= FF_ER_AGGRESSIVE) {
++            if        (s->mb_x + s->mb_y*s->mb_width + 1 >  next && (s->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
 +                return -1;
 +            } else if (s->mb_x + s->mb_y*s->mb_width + 1 >= next)
 +                return SLICE_END;
  
 -            if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta]) {
 +            if(s->pict_type==AV_PICTURE_TYPE_B){
 +                const int delta= s->mb_x + 1 == s->mb_width ? 2 : 1;
                  ff_thread_await_progress((AVFrame*)s->next_picture_ptr,
                                          (s->mb_x + delta >= s->mb_width) ? FFMIN(s->mb_y+1, s->mb_height-1) : s->mb_y, 0);
 +                if (s->next_picture.f.mbskip_table[xy + delta])
 +                    return SLICE_OK;
              }
  
 -            if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture.f.mbskip_table[xy + delta])
 -                return SLICE_OK;
              return SLICE_END;
          }
      }
Simple merge
Simple merge
@@@ -385,15 -379,11 +381,9 @@@ av_cold int MPV_encode_init(AVCodecCont
                          !s->fixed_qscale;
  
      s->loop_filter      = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
- #if FF_API_MPEGVIDEO_GLOBAL_OPTS
-     s->alternate_scan   = !!(s->flags  & CODEC_FLAG_ALT_SCAN);
-     s->intra_vlc_format = !!(s->flags2 & CODEC_FLAG2_INTRA_VLC);
-     s->q_scale_type     = !!(s->flags2 & CODEC_FLAG2_NON_LINEAR_QUANT);
-     s->obmc             = !!(s->flags  & CODEC_FLAG_OBMC);
- #endif
  
 -    if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "a vbv buffer size is needed, "
 -               "for encoding with a maximum bitrate\n");
 +    if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
 +        av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
          return -1;
      }
  
           s->codec_id == CODEC_ID_H263P) &&
          (avctx->sample_aspect_ratio.num > 255 ||
           avctx->sample_aspect_ratio.den > 255)) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
 +        av_log(avctx, AV_LOG_WARNING,
 +               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
                 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 -        return -1;
 +        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 +                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
      }
  
-     if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME
- #if FF_API_MPEGVIDEO_GLOBAL_OPTS
-                     | CODEC_FLAG_ALT_SCAN
- #endif
-         )) &&
+     if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
          s->codec_id != CODEC_ID_MPEG4 && s->codec_id != CODEC_ID_MPEG2VIDEO) {
          av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
          return -1;
@@@ -201,27 -174,13 +176,16 @@@ static const AVOption options[]=
  {"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
  {"experimental", "allow non standardized experimental things", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
  {"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
- #if FF_API_ER
- {"er", "set error detection aggressivity", OFFSET(error_recognition), AV_OPT_TYPE_INT, {.dbl = FF_ER_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "er"},
- {"careful", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_ER_CAREFUL }, INT_MIN, INT_MAX, V|D, "er"},
- {"compliant", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_ER_COMPLIANT }, INT_MIN, INT_MAX, V|D, "er"},
- {"aggressive", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_ER_AGGRESSIVE }, INT_MIN, INT_MAX, V|D, "er"},
- {"very_aggressive", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_ER_VERY_AGGRESSIVE }, INT_MIN, INT_MAX, V|D, "er"},
- {"explode", "abort decoding on error recognition", 0, AV_OPT_TYPE_CONST, {.dbl = FF_ER_EXPLODE }, INT_MIN, INT_MAX, V|D, "er"},
- #endif /* FF_API_ER */
  {"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 -{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, V|D, "err_detect"},
 +{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 +{"aggressive", "consider things that a sane encoder shouldnt do as an error", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
  {"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  {"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
- #if FF_API_PARSE_FRAME
- {"parse_only", NULL, OFFSET(parse_only), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
- #endif
  {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"stats_out", NULL, OFFSET(stats_out), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX},
  {"stats_in", NULL, OFFSET(stats_in), AV_OPT_TYPE_STRING, {.str = NULL}, CHAR_MIN, CHAR_MAX},
  {"all"             , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), AV_OPT_TYPE_INT, {.dbl = 1 }, 0, 4, V|E},
  {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, 10, V|E},
- #if FF_API_X264_GLOBAL_OPTS
- {"crf", "enables constant quality mode, and selects the quality (x264/VP8)", OFFSET(crf), AV_OPT_TYPE_FLOAT, {.dbl = DEFAULT }, 0, 63, V|E},
- {"cqp", "constant quantization parameter rate control method", OFFSET(cqp), AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, V|E},
- #endif
 -{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 -{"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
 +{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 +{"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
  {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
- #if FF_API_X264_GLOBAL_OPTS
- {"bframebias", "influences how often B-frames are used", OFFSET(bframebias), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
- #endif
  {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
- #if FF_API_X264_GLOBAL_OPTS
- {"directpred", "direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal), 3 (auto)", OFFSET(directpred), AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, V|E},
- {"bpyramid", "allows B-frames to be used as references for predicting", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_BPYRAMID }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"wpred", "weighted biprediction for b-frames (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_WPRED }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"mixed_refs", "one reference per partition, as opposed to one reference per macroblock", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_MIXED_REFS }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"dct8x8", "high profile 8x8 transform (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_8X8DCT }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"fastpskip", "fast pskip (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_FASTPSKIP }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"aud", "access unit delimiters (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_AUD }, INT_MIN, INT_MAX, V|E, "flags2"},
- #endif
  {"skiprd", "RD optimal MB level residual skipping", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SKIP_RD }, INT_MIN, INT_MAX, V|E, "flags2"},
- #if FF_API_X264_GLOBAL_OPTS
- {"complexityblur", "reduce fluctuations in qp (before curve compression)", OFFSET(complexityblur), AV_OPT_TYPE_FLOAT, {.dbl = -1 }, -1, FLT_MAX, V|E},
- {"deblockalpha", "in-loop deblocking filter alphac0 parameter", OFFSET(deblockalpha), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, -6, 6, V|E},
- {"deblockbeta", "in-loop deblocking filter beta parameter", OFFSET(deblockbeta), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, -6, 6, V|E},
- {"partitions", "macroblock subpartition sizes to consider", OFFSET(partitions), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "partitions"},
- {"parti4x4", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = X264_PART_I4X4 }, INT_MIN, INT_MAX, V|E, "partitions"},
- {"parti8x8", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = X264_PART_I8X8 }, INT_MIN, INT_MAX, V|E, "partitions"},
- {"partp4x4", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = X264_PART_P4X4 }, INT_MIN, INT_MAX, V|E, "partitions"},
- {"partp8x8", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = X264_PART_P8X8 }, INT_MIN, INT_MAX, V|E, "partitions"},
- {"partb8x8", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = X264_PART_B8X8 }, INT_MIN, INT_MAX, V|E, "partitions"},
- #endif
  {"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor), AV_OPT_TYPE_INT, {.dbl = 6 }, 0, INT_MAX, V|E},
  {"mv0_threshold", NULL, OFFSET(mv0_threshold), AV_OPT_TYPE_INT, {.dbl = 256 }, 0, INT_MAX, V|E},
- #if FF_API_MPEGVIDEO_GLOBAL_OPTS
- {"ivlc", "intra vlc table", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_INTRA_VLC }, INT_MIN, INT_MAX, V|E, "flags2"},
- #endif
  {"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity), AV_OPT_TYPE_INT, {.dbl = 40 }, 1, INT_MAX, V|E},
  {"compression_level", NULL, OFFSET(compression_level), AV_OPT_TYPE_INT, {.dbl = FF_COMPRESSION_DEFAULT }, INT_MIN, INT_MAX, V|A|E},
  {"min_prediction_order", NULL, OFFSET(min_prediction_order), AV_OPT_TYPE_INT, {.dbl = -1 }, INT_MIN, INT_MAX, A|E},
@@@ -70,7 -87,11 +87,11 @@@ static int sunrast_decode_frame(AVCodec
      maplength = AV_RB32(buf+28);
      buf      += 32;
  
 -    if (type == RT_FORMAT_TIFF || type == RT_FORMAT_IFF || type == RT_EXPERIMENTAL) {
++    if (type == RT_EXPERIMENTAL) {
+         av_log(avctx, AV_LOG_ERROR, "unsupported (compression) type\n");
+         return -1;
+     }
 -    if (type < RT_OLD || type > RT_FORMAT_IFF) {
 +    if (type > RT_FORMAT_IFF) {
          av_log(avctx, AV_LOG_ERROR, "invalid (compression) type\n");
          return -1;
      }
Simple merge
@@@ -799,26 -713,13 +796,16 @@@ int attribute_align_arg avcodec_open2(A
          goto free_and_end;
      }
      avctx->frame_number = 0;
- #if FF_API_ER
  
-     av_log(avctx, AV_LOG_DEBUG, "err{or,}_recognition separate: %d; %X\n",
-            avctx->error_recognition, avctx->err_recognition);
-     switch(avctx->error_recognition){
-         case FF_ER_EXPLODE        : avctx->err_recognition |= AV_EF_EXPLODE | AV_EF_COMPLIANT | AV_EF_CAREFUL;
-             break;
-         case FF_ER_VERY_AGGRESSIVE:
-         case FF_ER_AGGRESSIVE     : avctx->err_recognition |= AV_EF_AGGRESSIVE;
-         case FF_ER_COMPLIANT      : avctx->err_recognition |= AV_EF_COMPLIANT;
-         case FF_ER_CAREFUL        : avctx->err_recognition |= AV_EF_CAREFUL;
+     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
+         (!avctx->time_base.num || !avctx->time_base.den)) {
+         avctx->time_base.num = 1;
+         avctx->time_base.den = avctx->sample_rate;
      }
  
-     av_log(avctx, AV_LOG_DEBUG, "err{or,}_recognition combined: %d; %X\n",
-            avctx->error_recognition, avctx->err_recognition);
- #endif
 +    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) {
@@@ -1683,13 -1513,6 +1670,13 @@@ const char *av_get_profile_name(const A
  
  unsigned avcodec_version( void )
  {
-     av_assert0(CODEC_ID_V410==164);
++//    av_assert0(CODEC_ID_V410==164);
 +    av_assert0(CODEC_ID_PCM_S8_PLANAR==65563);
 +    av_assert0(CODEC_ID_ADPCM_G722==69660);
-     av_assert0(CODEC_ID_BMV_AUDIO==86071);
++//     av_assert0(CODEC_ID_BMV_AUDIO==86071);
 +    av_assert0(CODEC_ID_SRT==94216);
 +    av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
 +
    return LIBAVCODEC_VERSION_INT;
  }
  
@@@ -1982,22 -1790,8 +1957,14 @@@ void ff_thread_await_progress(AVFrame *
  
  #endif
  
- #if FF_API_THREAD_INIT
- int avcodec_thread_init(AVCodecContext *s, int thread_count)
- {
-     s->thread_count = thread_count;
-     return ff_thread_init(s);
- }
- #endif
  enum AVMediaType avcodec_get_type(enum CodecID codec_id)
  {
 +    AVCodec *c= avcodec_find_decoder(codec_id);
 +    if(!c)
 +        c= avcodec_find_encoder(codec_id);
 +    if(c)
 +        return c->type;
 +
      if (codec_id <= CODEC_ID_NONE)
          return AVMEDIA_TYPE_UNKNOWN;
      else if (codec_id < CODEC_ID_FIRST_AUDIO)
Simple merge
@@@ -20,9 -20,9 +20,9 @@@
  #ifndef AVCODEC_VERSION_H
  #define AVCODEC_VERSION_H
  
- #define LIBAVCODEC_VERSION_MAJOR 53
- #define LIBAVCODEC_VERSION_MINOR 60
+ #define LIBAVCODEC_VERSION_MAJOR 54
+ #define LIBAVCODEC_VERSION_MINOR  0
 -#define LIBAVCODEC_VERSION_MICRO  0
 +#define LIBAVCODEC_VERSION_MICRO 100
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
                                                 LIBAVCODEC_VERSION_MINOR, \
  #ifndef FF_API_REQUEST_CHANNELS
  #define FF_API_REQUEST_CHANNELS (LIBAVCODEC_VERSION_MAJOR < 55)
  #endif
- #ifndef FF_API_OPT_H
- #define FF_API_OPT_H            (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_THREAD_INIT
- #define FF_API_THREAD_INIT      (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_OLD_FF_PICT_TYPES
- #define FF_API_OLD_FF_PICT_TYPES (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_FLAC_GLOBAL_OPTS
- #define FF_API_FLAC_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_GET_PIX_FMT_NAME
- #define FF_API_GET_PIX_FMT_NAME (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
 +#ifndef FF_API_ALLOC_CONTEXT
- #define FF_API_ALLOC_CONTEXT    (LIBAVCODEC_VERSION_MAJOR < 54)
++#define FF_API_ALLOC_CONTEXT    (LIBAVCODEC_VERSION_MAJOR < 55)
 +#endif
 +#ifndef FF_API_AVCODEC_OPEN
- #define FF_API_AVCODEC_OPEN     (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_DRC_SCALE
- #define FF_API_DRC_SCALE        (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_ER
- #define FF_API_ER               (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_AVCODEC_INIT
- #define FF_API_AVCODEC_INIT     (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_X264_GLOBAL_OPTS
- #define FF_API_X264_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_MPEGVIDEO_GLOBAL_OPTS
- #define FF_API_MPEGVIDEO_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_LAME_GLOBAL_OPTS
- #define FF_API_LAME_GLOBAL_OPTS  (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_SNOW_GLOBAL_OPTS
- #define FF_API_SNOW_GLOBAL_OPTS  (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_MJPEG_GLOBAL_OPTS
- #define FF_API_MJPEG_GLOBAL_OPTS (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_GET_ALPHA_INFO
- #define FF_API_GET_ALPHA_INFO    (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_PARSE_FRAME
- #define FF_API_PARSE_FRAME (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_INTERNAL_CONTEXT
- #define FF_API_INTERNAL_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_TIFFENC_COMPLEVEL
- #define FF_API_TIFFENC_COMPLEVEL (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
- #ifndef FF_API_DATA_POINTERS
- #define FF_API_DATA_POINTERS (LIBAVCODEC_VERSION_MAJOR < 54)
++#define FF_API_AVCODEC_OPEN     (LIBAVCODEC_VERSION_MAJOR < 55)
 +#endif
  #ifndef FF_API_OLD_DECODE_AUDIO
  #define FF_API_OLD_DECODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
  #endif
- #define FF_API_OLD_TIMECODE (LIBAVCODEC_VERSION_MAJOR < 54)
 +#ifndef FF_API_OLD_TIMECODE
- #ifndef FF_API_AVFRAME_AGE
- #define FF_API_AVFRAME_AGE (LIBAVCODEC_VERSION_MAJOR < 54)
- #endif
++#define FF_API_OLD_TIMECODE (LIBAVCODEC_VERSION_MAJOR < 55)
 +#endif
 +
  #ifndef FF_API_OLD_ENCODE_AUDIO
  #define FF_API_OLD_ENCODE_AUDIO (LIBAVCODEC_VERSION_MAJOR < 55)
  #endif
Simple merge
Simple merge
index 4c5a5d7,0000000..60edac9
mode 100644,000000..100644
--- /dev/null
@@@ -1,260 -1,0 +1,260 @@@
- %ifdef ARCH_X86_64
 +;******************************************************************************
 +;* Copyright (c) 2010 David Conrad
 +;*
 +;* This file is part of FFmpeg.
 +;*
 +;* 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.
 +;*
 +;* 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
 +;* 51, Inc., Foundation Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 +;******************************************************************************
 +
 +%include "x86inc.asm"
 +
 +SECTION_RODATA
 +pw_3: times 8 dw 3
 +pw_7: times 8 dw 7
 +pw_16: times 8 dw 16
 +pw_32: times 8 dw 32
 +pb_128: times 16 db 128
 +
 +section .text
 +
 +%macro UNPACK_ADD 6
 +    mov%5   %1, %3
 +    mov%6   m5, %4
 +    mova    m4, %1
 +    mova    %2, m5
 +    punpcklbw %1, m7
 +    punpcklbw m5, m7
 +    punpckhbw m4, m7
 +    punpckhbw %2, m7
 +    paddw   %1, m5
 +    paddw   %2, m4
 +%endmacro
 +
 +%macro HPEL_FILTER 1
 +; dirac_hpel_filter_v_sse2(uint8_t *dst, uint8_t *src, int stride, int width);
 +cglobal dirac_hpel_filter_v_%1, 4,6,8, dst, src, stride, width, src0, stridex3
 +    mov     src0q, srcq
 +    lea     stridex3q, [3*strideq]
 +    sub     src0q, stridex3q
 +    pxor    m7, m7
 +.loop:
 +    ; 7*(src[0] + src[1])
 +    UNPACK_ADD m0, m1, [srcq], [srcq + strideq], a,a
 +    pmullw  m0, [pw_7]
 +    pmullw  m1, [pw_7]
 +
 +    ; 3*( ... + src[-2] + src[3])
 +    UNPACK_ADD m2, m3, [src0q + strideq], [srcq + stridex3q], a,a
 +    paddw   m0, m2
 +    paddw   m1, m3
 +    pmullw  m0, [pw_3]
 +    pmullw  m1, [pw_3]
 +
 +    ; ... - 7*(src[-1] + src[2])
 +    UNPACK_ADD m2, m3, [src0q + strideq*2], [srcq + strideq*2], a,a
 +    pmullw  m2, [pw_7]
 +    pmullw  m3, [pw_7]
 +    psubw   m0, m2
 +    psubw   m1, m3
 +
 +    ; ... - (src[-3] + src[4])
 +    UNPACK_ADD m2, m3, [src0q], [srcq + strideq*4], a,a
 +    psubw   m0, m2
 +    psubw   m1, m3
 +
 +    paddw   m0, [pw_16]
 +    paddw   m1, [pw_16]
 +    psraw   m0, 5
 +    psraw   m1, 5
 +    packuswb m0, m1
 +    mova    [dstq], m0
 +    add     dstq, mmsize
 +    add     srcq, mmsize
 +    add     src0q, mmsize
 +    sub     widthd, mmsize
 +    jg      .loop
 +    RET
 +
 +; dirac_hpel_filter_h_sse2(uint8_t *dst, uint8_t *src, int width);
 +cglobal dirac_hpel_filter_h_%1, 3,3,8, dst, src, width
 +    dec     widthd
 +    pxor    m7, m7
 +    and     widthd, ~(mmsize-1)
 +.loop:
 +    ; 7*(src[0] + src[1])
 +    UNPACK_ADD m0, m1, [srcq + widthq], [srcq + widthq + 1], u,u
 +    pmullw  m0, [pw_7]
 +    pmullw  m1, [pw_7]
 +
 +    ; 3*( ... + src[-2] + src[3])
 +    UNPACK_ADD m2, m3, [srcq + widthq - 2], [srcq + widthq + 3], u,u
 +    paddw   m0, m2
 +    paddw   m1, m3
 +    pmullw  m0, [pw_3]
 +    pmullw  m1, [pw_3]
 +
 +    ; ... - 7*(src[-1] + src[2])
 +    UNPACK_ADD m2, m3, [srcq + widthq - 1], [srcq + widthq + 2], u,u
 +    pmullw  m2, [pw_7]
 +    pmullw  m3, [pw_7]
 +    psubw   m0, m2
 +    psubw   m1, m3
 +
 +    ; ... - (src[-3] + src[4])
 +    UNPACK_ADD m2, m3, [srcq + widthq - 3], [srcq + widthq + 4], u,u
 +    psubw   m0, m2
 +    psubw   m1, m3
 +
 +    paddw   m0, [pw_16]
 +    paddw   m1, [pw_16]
 +    psraw   m0, 5
 +    psraw   m1, 5
 +    packuswb m0, m1
 +    mova    [dstq + widthq], m0
 +    sub     widthd, mmsize
 +    jge     .loop
 +    RET
 +%endmacro
 +
 +%macro PUT_RECT 1
 +; void put_rect_clamped(uint8_t *dst, int dst_stride, int16_t *src, int src_stride, int width, int height)
 +cglobal put_signed_rect_clamped_%1, 5,7,3, dst, dst_stride, src, src_stride, w, dst2, src2
 +    mova    m0, [pb_128]
 +    add     wd, (mmsize-1)
 +    and     wd, ~(mmsize-1)
 +
- %ifdef ARCH_X86_64
++%if ARCH_X86_64
 +    mov   r10d, r5m
 +    mov   r11d, wd
 +    %define wspill r11d
 +    %define hd r10d
 +%else
 +    mov    r4m, wd
 +    %define wspill r4m
 +    %define hd r5mp
 +%endif
 +
 +.loopy
 +    lea     src2q, [srcq+src_strideq*2]
 +    lea     dst2q, [dstq+dst_strideq]
 +.loopx:
 +    sub      wd, mmsize
 +    mova     m1, [srcq +2*wq]
 +    mova     m2, [src2q+2*wq]
 +    packsswb m1, [srcq +2*wq+mmsize]
 +    packsswb m2, [src2q+2*wq+mmsize]
 +    paddb    m1, m0
 +    paddb    m2, m0
 +    mova    [dstq +wq], m1
 +    mova    [dst2q+wq], m2
 +    jg      .loopx
 +
 +    lea   srcq, [srcq+src_strideq*4]
 +    lea   dstq, [dstq+dst_strideq*2]
 +    sub     hd, 2
 +    mov     wd, wspill
 +    jg      .loopy
 +    RET
 +%endm
 +
 +%macro ADD_RECT 1
 +; void add_rect_clamped(uint8_t *dst, uint16_t *src, int stride, int16_t *idwt, int idwt_stride, int width, int height)
 +cglobal add_rect_clamped_%1, 7,7,3, dst, src, stride, idwt, idwt_stride, w, h
 +    mova    m0, [pw_32]
 +    add     wd, (mmsize-1)
 +    and     wd, ~(mmsize-1)
 +
++%if ARCH_X86_64
 +    mov   r11d, wd
 +    %define wspill r11d
 +%else
 +    mov    r5m, wd
 +    %define wspill r5m
 +%endif
 +
 +.loop:
 +    sub     wd, mmsize
 +    movu    m1, [srcq +2*wq] ; FIXME: ensure alignment
 +    paddw   m1, m0
 +    psraw   m1, 6
 +    movu    m2, [srcq +2*wq+mmsize] ; FIXME: ensure alignment
 +    paddw   m2, m0
 +    psraw   m2, 6
 +    paddw   m1, [idwtq+2*wq]
 +    paddw   m2, [idwtq+2*wq+mmsize]
 +    packuswb m1, m2
 +    mova    [dstq +wq], m1
 +    jg      .loop
 +
 +    lea   srcq, [srcq + 2*strideq]
 +    add   dstq, strideq
 +    lea  idwtq, [idwtq+ 2*idwt_strideq]
 +    sub     hd, 1
 +    mov     wd, wspill
 +    jg      .loop
 +    RET
 +%endm
 +
 +%macro ADD_OBMC 2
 +; void add_obmc(uint16_t *dst, uint8_t *src, int stride, uint8_t *obmc_weight, int yblen)
 +cglobal add_dirac_obmc%1_%2, 6,6,5, dst, src, stride, obmc, yblen
 +    pxor        m4, m4
 +.loop:
 +%assign i 0
 +%rep %1 / mmsize
 +    mova        m0, [srcq+i]
 +    mova        m1, m0
 +    punpcklbw   m0, m4
 +    punpckhbw   m1, m4
 +    mova        m2, [obmcq+i]
 +    mova        m3, m2
 +   punpcklbw   m2, m4
 +    punpckhbw   m3, m4
 +    pmullw      m0, m2
 +    pmullw      m1, m3
 +    movu        m2, [dstq+2*i]
 +    movu        m3, [dstq+2*i+mmsize]
 +    paddw       m0, m2
 +    paddw       m1, m3
 +    movu        [dstq+2*i], m0
 +    movu        [dstq+2*i+mmsize], m1
 +%assign i i+mmsize
 +%endrep
 +    lea         srcq, [srcq+strideq]
 +    lea         dstq, [dstq+2*strideq]
 +    add         obmcq, 32
 +    sub         yblend, 1
 +    jg          .loop
 +    RET
 +%endm
 +
 +INIT_MMX
 +%ifndef ARCH_X86_64
 +PUT_RECT mmx
 +ADD_RECT mmx
 +
 +HPEL_FILTER mmx
 +ADD_OBMC 32, mmx
 +ADD_OBMC 16, mmx
 +%endif
 +ADD_OBMC 8, mmx
 +
 +INIT_XMM
 +PUT_RECT sse2
 +ADD_RECT sse2
 +
 +HPEL_FILTER sse2
 +ADD_OBMC 32, sse2
 +ADD_OBMC 16, sse2
Simple merge
Simple merge
@@@ -28,9 -28,9 +28,9 @@@
  ; in blocks as conventient to the vector size.
  ; i.e. {4x real, 4x imaginary, 4x real, ...} (or 2x respectively)
  
 -%include "x86inc.asm"
 +%include "libavutil/x86/x86inc.asm"
  
- %ifdef ARCH_X86_64
+ %if ARCH_X86_64
  %define pointer resq
  %else
  %define pointer resd
Simple merge
Simple merge
@@@ -781,11 -777,9 +781,11 @@@ cglobal deblock_h_luma_intra_8_%1, 2,
  
  INIT_XMM
  DEBLOCK_LUMA_INTRA sse2, v
 +%ifdef HAVE_AVX
  INIT_AVX
  DEBLOCK_LUMA_INTRA avx , v
- %ifndef ARCH_X86_64
 +%endif
+ %if ARCH_X86_64 == 0
  INIT_MMX
  DEBLOCK_LUMA_INTRA mmxext, v8
  %endif
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
   */
  
  #include <alsa/asoundlib.h>
 -#include "libavformat/avformat.h"
  #include "libavformat/internal.h"
  #include "libavutil/opt.h"
 +#include "libavutil/mathematics.h"
  
 +#include "avdevice.h"
  #include "alsa-audio.h"
  
- static av_cold int audio_read_header(AVFormatContext *s1,
-                                      AVFormatParameters *ap)
+ static av_cold int audio_read_header(AVFormatContext *s1)
  {
      AlsaData *s = s1->priv_data;
      AVStream *st;
Simple merge
index 61f0d08,0000000..dd1b29b
mode 100644,000000..100644
--- /dev/null
@@@ -1,973 -1,0 +1,973 @@@
- static enum SampleFormat sample_fmt_bits_per_sample(int bits)
 +/*
 + * Directshow capture interface
 + * Copyright (c) 2010 Ramiro Polla
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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 "libavutil/parseutils.h"
 +#include "libavutil/opt.h"
 +#include "libavformat/internal.h"
 +#include "avdevice.h"
 +#include "dshow.h"
 +
 +struct dshow_ctx {
 +    const AVClass *class;
 +
 +    IGraphBuilder *graph;
 +
 +    char *device_name[2];
 +    int video_device_number;
 +    int audio_device_number;
 +
 +    int   list_options;
 +    int   list_devices;
 +
 +    IBaseFilter *device_filter[2];
 +    IPin        *device_pin[2];
 +    libAVFilter *capture_filter[2];
 +    libAVPin    *capture_pin[2];
 +
 +    HANDLE mutex;
 +    HANDLE event;
 +    AVPacketList *pktl;
 +
 +    unsigned int curbufsize;
 +    unsigned int video_frame_num;
 +
 +    IMediaControl *control;
 +
 +    char *video_size;
 +    char *framerate;
 +
 +    int requested_width;
 +    int requested_height;
 +    AVRational requested_framerate;
 +
 +    int sample_rate;
 +    int sample_size;
 +    int channels;
 +};
 +
 +static enum PixelFormat dshow_pixfmt(DWORD biCompression, WORD biBitCount)
 +{
 +    switch(biCompression) {
 +    case MKTAG('U', 'Y', 'V', 'Y'):
 +        return PIX_FMT_UYVY422;
 +    case MKTAG('Y', 'U', 'Y', '2'):
 +        return PIX_FMT_YUYV422;
 +    case MKTAG('I', '4', '2', '0'):
 +        return PIX_FMT_YUV420P;
 +    case BI_BITFIELDS:
 +    case BI_RGB:
 +        switch(biBitCount) { /* 1-8 are untested */
 +            case 1:
 +                return PIX_FMT_MONOWHITE;
 +            case 4:
 +                return PIX_FMT_RGB4;
 +            case 8:
 +                return PIX_FMT_RGB8;
 +            case 16:
 +                return PIX_FMT_RGB555;
 +            case 24:
 +                return PIX_FMT_BGR24;
 +            case 32:
 +                return PIX_FMT_RGB32;
 +        }
 +    }
 +    return PIX_FMT_NONE;
 +}
 +
 +static enum CodecID dshow_codecid(DWORD biCompression)
 +{
 +    switch(biCompression) {
 +    case MKTAG('d', 'v', 's', 'd'):
 +        return CODEC_ID_DVVIDEO;
 +    case MKTAG('M', 'J', 'P', 'G'):
 +    case MKTAG('m', 'j', 'p', 'g'):
 +        return CODEC_ID_MJPEG;
 +    }
 +    return CODEC_ID_NONE;
 +}
 +
 +static int
 +dshow_read_close(AVFormatContext *s)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList *pktl;
 +
 +    if (ctx->control) {
 +        IMediaControl_Stop(ctx->control);
 +        IMediaControl_Release(ctx->control);
 +    }
 +
 +    if (ctx->graph) {
 +        IEnumFilters *fenum;
 +        int r;
 +        r = IGraphBuilder_EnumFilters(ctx->graph, &fenum);
 +        if (r == S_OK) {
 +            IBaseFilter *f;
 +            IEnumFilters_Reset(fenum);
 +            while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK) {
 +                if (IGraphBuilder_RemoveFilter(ctx->graph, f) == S_OK)
 +                    IEnumFilters_Reset(fenum); /* When a filter is removed,
 +                                                * the list must be reset. */
 +                IBaseFilter_Release(f);
 +            }
 +            IEnumFilters_Release(fenum);
 +        }
 +        IGraphBuilder_Release(ctx->graph);
 +    }
 +
 +    if (ctx->capture_pin[VideoDevice])
 +        libAVPin_Release(ctx->capture_pin[VideoDevice]);
 +    if (ctx->capture_pin[AudioDevice])
 +        libAVPin_Release(ctx->capture_pin[AudioDevice]);
 +    if (ctx->capture_filter[VideoDevice])
 +        libAVFilter_Release(ctx->capture_filter[VideoDevice]);
 +    if (ctx->capture_filter[AudioDevice])
 +        libAVFilter_Release(ctx->capture_filter[AudioDevice]);
 +
 +    if (ctx->device_pin[VideoDevice])
 +        IPin_Release(ctx->device_pin[VideoDevice]);
 +    if (ctx->device_pin[AudioDevice])
 +        IPin_Release(ctx->device_pin[AudioDevice]);
 +    if (ctx->device_filter[VideoDevice])
 +        IBaseFilter_Release(ctx->device_filter[VideoDevice]);
 +    if (ctx->device_filter[AudioDevice])
 +        IBaseFilter_Release(ctx->device_filter[AudioDevice]);
 +
 +    if (ctx->device_name[0])
 +        av_free(ctx->device_name[0]);
 +    if (ctx->device_name[1])
 +        av_free(ctx->device_name[1]);
 +
 +    if(ctx->mutex)
 +        CloseHandle(ctx->mutex);
 +    if(ctx->event)
 +        CloseHandle(ctx->event);
 +
 +    pktl = ctx->pktl;
 +    while (pktl) {
 +        AVPacketList *next = pktl->next;
 +        av_destruct_packet(&pktl->pkt);
 +        av_free(pktl);
 +        pktl = next;
 +    }
 +
 +    return 0;
 +}
 +
 +static char *dup_wchar_to_utf8(wchar_t *w)
 +{
 +    char *s = NULL;
 +    int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
 +    s = av_malloc(l);
 +    if (s)
 +        WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
 +    return s;
 +}
 +
 +static int shall_we_drop(AVFormatContext *s)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    const uint8_t dropscore[] = {62, 75, 87, 100};
 +    const int ndropscores = FF_ARRAY_ELEMS(dropscore);
 +    unsigned int buffer_fullness = (ctx->curbufsize*100)/s->max_picture_buffer;
 +
 +    if(dropscore[++ctx->video_frame_num%ndropscores] <= buffer_fullness) {
 +        av_log(s, AV_LOG_ERROR,
 +              "real-time buffer %d%% full! frame dropped!\n", buffer_fullness);
 +        return 1;
 +    }
 +
 +    return 0;
 +}
 +
 +static void
 +callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time)
 +{
 +    AVFormatContext *s = priv_data;
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList **ppktl, *pktl_next;
 +
 +//    dump_videohdr(s, vdhdr);
 +
 +    if(shall_we_drop(s))
 +        return;
 +
 +    WaitForSingleObject(ctx->mutex, INFINITE);
 +
 +    pktl_next = av_mallocz(sizeof(AVPacketList));
 +    if(!pktl_next)
 +        goto fail;
 +
 +    if(av_new_packet(&pktl_next->pkt, buf_size) < 0) {
 +        av_free(pktl_next);
 +        goto fail;
 +    }
 +
 +    pktl_next->pkt.stream_index = index;
 +    pktl_next->pkt.pts = time;
 +    memcpy(pktl_next->pkt.data, buf, buf_size);
 +
 +    for(ppktl = &ctx->pktl ; *ppktl ; ppktl = &(*ppktl)->next);
 +    *ppktl = pktl_next;
 +
 +    ctx->curbufsize += buf_size;
 +
 +    SetEvent(ctx->event);
 +    ReleaseMutex(ctx->mutex);
 +
 +    return;
 +fail:
 +    ReleaseMutex(ctx->mutex);
 +    return;
 +}
 +
 +/**
 + * Cycle through available devices using the device enumerator devenum,
 + * retrieve the device with type specified by devtype and return the
 + * pointer to the object found in *pfilter.
 + * If pfilter is NULL, list all device names.
 + */
 +static int
 +dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                    enum dshowDeviceType devtype, IBaseFilter **pfilter)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    IEnumMoniker *classenum = NULL;
 +    IMoniker *m = NULL;
 +    const char *device_name = ctx->device_name[devtype];
 +    int skip = (devtype == VideoDevice) ? ctx->video_device_number
 +                                        : ctx->audio_device_number;
 +    int r;
 +
 +    const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,
 +                                   &CLSID_AudioInputDeviceCategory };
 +    const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 +
 +    r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[devtype],
 +                                             (IEnumMoniker **) &classenum, 0);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices.\n",
 +               devtypename);
 +        return AVERROR(EIO);
 +    }
 +
 +    while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {
 +        IPropertyBag *bag = NULL;
 +        char *buf = NULL;
 +        VARIANT var;
 +
 +        r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);
 +        if (r != S_OK)
 +            goto fail1;
 +
 +        var.vt = VT_BSTR;
 +        r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
 +        if (r != S_OK)
 +            goto fail1;
 +
 +        buf = dup_wchar_to_utf8(var.bstrVal);
 +
 +        if (pfilter) {
 +            if (strcmp(device_name, buf))
 +                goto fail1;
 +
 +            if (!skip--)
 +                IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);
 +        } else {
 +            av_log(avctx, AV_LOG_INFO, " \"%s\"\n", buf);
 +        }
 +
 +fail1:
 +        if (buf)
 +            av_free(buf);
 +        if (bag)
 +            IPropertyBag_Release(bag);
 +        IMoniker_Release(m);
 +    }
 +
 +    IEnumMoniker_Release(classenum);
 +
 +    if (pfilter) {
 +        if (!device_filter) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not find %s device.\n",
 +                   devtypename);
 +            return AVERROR(EIO);
 +        }
 +        *pfilter = device_filter;
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * Cycle through available formats using the specified pin,
 + * try to set parameters specified through AVOptions and if successful
 + * return 1 in *pformat_set.
 + * If pformat_set is NULL, list all pin capabilities.
 + */
 +static void
 +dshow_cycle_formats(AVFormatContext *avctx, enum dshowDeviceType devtype,
 +                    IPin *pin, int *pformat_set)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IAMStreamConfig *config = NULL;
 +    AM_MEDIA_TYPE *type = NULL;
 +    int format_set = 0;
 +    void *caps = NULL;
 +    int i, n, size;
 +
 +    if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)
 +        return;
 +    if (IAMStreamConfig_GetNumberOfCapabilities(config, &n, &size) != S_OK)
 +        goto end;
 +
 +    caps = av_malloc(size);
 +    if (!caps)
 +        goto end;
 +
 +    for (i = 0; i < n && !format_set; i++) {
 +        IAMStreamConfig_GetStreamCaps(config, i, &type, (void *) caps);
 +
 +#if DSHOWDEBUG
 +        ff_print_AM_MEDIA_TYPE(type);
 +#endif
 +
 +        if (devtype == VideoDevice) {
 +            VIDEO_STREAM_CONFIG_CAPS *vcaps = caps;
 +            BITMAPINFOHEADER *bih;
 +            int64_t *fr;
 +#if DSHOWDEBUG
 +            ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);
 +#endif
 +            if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {
 +                VIDEOINFOHEADER *v = (void *) type->pbFormat;
 +                fr = &v->AvgTimePerFrame;
 +                bih = &v->bmiHeader;
 +            } else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
 +                VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
 +                fr = &v->AvgTimePerFrame;
 +                bih = &v->bmiHeader;
 +            } else {
 +                goto next;
 +            }
 +            if (!pformat_set) {
 +                av_log(avctx, AV_LOG_INFO, "  min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
 +                       vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
 +                       1e7 / vcaps->MaxFrameInterval,
 +                       vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
 +                       1e7 / vcaps->MinFrameInterval);
 +                continue;
 +            }
 +            if (ctx->framerate) {
 +                int64_t framerate = ((int64_t) ctx->requested_framerate.den*10000000)
 +                                            /  ctx->requested_framerate.num;
 +                if (framerate > vcaps->MaxFrameInterval ||
 +                    framerate < vcaps->MinFrameInterval)
 +                    goto next;
 +                *fr = framerate;
 +            }
 +            if (ctx->video_size) {
 +                if (ctx->requested_width  > vcaps->MaxOutputSize.cx ||
 +                    ctx->requested_width  < vcaps->MinOutputSize.cx ||
 +                    ctx->requested_height > vcaps->MaxOutputSize.cy ||
 +                    ctx->requested_height < vcaps->MinOutputSize.cy)
 +                    goto next;
 +                bih->biWidth  = ctx->requested_width;
 +                bih->biHeight = ctx->requested_height;
 +            }
 +        } else {
 +            AUDIO_STREAM_CONFIG_CAPS *acaps = caps;
 +            WAVEFORMATEX *fx;
 +#if DSHOWDEBUG
 +            ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);
 +#endif
 +            if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {
 +                fx = (void *) type->pbFormat;
 +            } else {
 +                goto next;
 +            }
 +            if (!pformat_set) {
 +                av_log(avctx, AV_LOG_INFO, "  min ch=%lu bits=%lu rate=%6lu max ch=%lu bits=%lu rate=%6lu\n",
 +                       acaps->MinimumChannels, acaps->MinimumBitsPerSample, acaps->MinimumSampleFrequency,
 +                       acaps->MaximumChannels, acaps->MaximumBitsPerSample, acaps->MaximumSampleFrequency);
 +                continue;
 +            }
 +            if (ctx->sample_rate) {
 +                if (ctx->sample_rate > acaps->MaximumSampleFrequency ||
 +                    ctx->sample_rate < acaps->MinimumSampleFrequency)
 +                    goto next;
 +                fx->nSamplesPerSec = ctx->sample_rate;
 +            }
 +            if (ctx->sample_size) {
 +                if (ctx->sample_size > acaps->MaximumBitsPerSample ||
 +                    ctx->sample_size < acaps->MinimumBitsPerSample)
 +                    goto next;
 +                fx->wBitsPerSample = ctx->sample_size;
 +            }
 +            if (ctx->channels) {
 +                if (ctx->channels > acaps->MaximumChannels ||
 +                    ctx->channels < acaps->MinimumChannels)
 +                    goto next;
 +                fx->nChannels = ctx->channels;
 +            }
 +        }
 +        if (IAMStreamConfig_SetFormat(config, type) != S_OK)
 +            goto next;
 +        format_set = 1;
 +next:
 +        if (type->pbFormat)
 +            CoTaskMemFree(type->pbFormat);
 +        CoTaskMemFree(type);
 +    }
 +end:
 +    IAMStreamConfig_Release(config);
 +    if (caps)
 +        av_free(caps);
 +    if (pformat_set)
 +        *pformat_set = format_set;
 +}
 +
 +/**
 + * Cycle through available pins using the device_filter device, of type
 + * devtype, retrieve the first output pin and return the pointer to the
 + * object found in *ppin.
 + * If ppin is NULL, cycle through all pins listing audio/video capabilities.
 + */
 +static int
 +dshow_cycle_pins(AVFormatContext *avctx, enum dshowDeviceType devtype,
 +                 IBaseFilter *device_filter, IPin **ppin)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IEnumPins *pins = 0;
 +    IPin *device_pin = NULL;
 +    IPin *pin;
 +    int r;
 +
 +    const GUID *mediatype[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
 +    const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 +
 +    int set_format = (devtype == VideoDevice && (ctx->video_size || ctx->framerate))
 +                  || (devtype == AudioDevice && (ctx->channels || ctx->sample_rate));
 +    int format_set = 0;
 +
 +    r = IBaseFilter_EnumPins(device_filter, &pins);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");
 +        return AVERROR(EIO);
 +    }
 +
 +    if (!ppin) {
 +        av_log(avctx, AV_LOG_INFO, "DirectShow %s device options\n",
 +               devtypename);
 +    }
 +    while (!device_pin && IEnumPins_Next(pins, 1, &pin, NULL) == S_OK) {
 +        IKsPropertySet *p = NULL;
 +        IEnumMediaTypes *types = NULL;
 +        PIN_INFO info = {0};
 +        AM_MEDIA_TYPE *type;
 +        GUID category;
 +        DWORD r2;
 +
 +        IPin_QueryPinInfo(pin, &info);
 +        IBaseFilter_Release(info.pFilter);
 +
 +        if (info.dir != PINDIR_OUTPUT)
 +            goto next;
 +        if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
 +            goto next;
 +        if (IKsPropertySet_Get(p, &AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
 +                               NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
 +            goto next;
 +        if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
 +            goto next;
 +
 +        if (!ppin) {
 +            char *buf = dup_wchar_to_utf8(info.achName);
 +            av_log(avctx, AV_LOG_INFO, " Pin \"%s\"\n", buf);
 +            av_free(buf);
 +            dshow_cycle_formats(avctx, devtype, pin, NULL);
 +            goto next;
 +        }
 +        if (set_format) {
 +            dshow_cycle_formats(avctx, devtype, pin, &format_set);
 +            if (!format_set) {
 +                goto next;
 +            }
 +        }
 +
 +        if (IPin_EnumMediaTypes(pin, &types) != S_OK)
 +            goto next;
 +
 +        IEnumMediaTypes_Reset(types);
 +        while (!device_pin && IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK) {
 +            if (IsEqualGUID(&type->majortype, mediatype[devtype])) {
 +                device_pin = pin;
 +                goto next;
 +            }
 +            CoTaskMemFree(type);
 +        }
 +
 +next:
 +        if (types)
 +            IEnumMediaTypes_Release(types);
 +        if (p)
 +            IKsPropertySet_Release(p);
 +        if (device_pin != pin)
 +            IPin_Release(pin);
 +    }
 +
 +    IEnumPins_Release(pins);
 +
 +    if (ppin) {
 +        if (set_format && !format_set) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not set %s options\n", devtypename);
 +            return AVERROR(EIO);
 +        }
 +        if (!device_pin) {
 +            av_log(avctx, AV_LOG_ERROR,
 +                "Could not find output pin from %s capture device.\n", devtypename);
 +            return AVERROR(EIO);
 +        }
 +        *ppin = device_pin;
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * List options for device with type devtype.
 + *
 + * @param devenum device enumerator used for accessing the device
 + */
 +static int
 +dshow_list_device_options(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                          enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    int r;
 +
 +    if ((r = dshow_cycle_devices(avctx, devenum, devtype, &device_filter)) < 0)
 +        return r;
 +    ctx->device_filter[devtype] = device_filter;
 +    if ((r = dshow_cycle_pins(avctx, devtype, device_filter, NULL)) < 0)
 +        return r;
 +
 +    return 0;
 +}
 +
 +static int
 +dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                  enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    IGraphBuilder *graph = ctx->graph;
 +    IPin *device_pin = NULL;
 +    libAVPin *capture_pin = NULL;
 +    libAVFilter *capture_filter = NULL;
 +    int ret = AVERROR(EIO);
 +    int r;
 +
 +    const wchar_t *filter_name[2] = { L"Audio capture filter", L"Video capture filter" };
 +
 +    if ((r = dshow_cycle_devices(avctx, devenum, devtype, &device_filter)) < 0) {
 +        ret = r;
 +        goto error;
 +    }
 +
 +    ctx->device_filter [devtype] = device_filter;
 +
 +    r = IGraphBuilder_AddFilter(graph, device_filter, NULL);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n");
 +        goto error;
 +    }
 +
 +    if ((r = dshow_cycle_pins(avctx, devtype, device_filter, &device_pin)) < 0) {
 +        ret = r;
 +        goto error;
 +    }
 +    ctx->device_pin[devtype] = device_pin;
 +
 +    capture_filter = libAVFilter_Create(avctx, callback, devtype);
 +    if (!capture_filter) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n");
 +        goto error;
 +    }
 +    ctx->capture_filter[devtype] = capture_filter;
 +
 +    r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter,
 +                                filter_name[devtype]);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n");
 +        goto error;
 +    }
 +
 +    libAVPin_AddRef(capture_filter->pin);
 +    capture_pin = capture_filter->pin;
 +    ctx->capture_pin[devtype] = capture_pin;
 +
 +    r = IGraphBuilder_ConnectDirect(graph, device_pin, (IPin *) capture_pin, NULL);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not connect pins\n");
 +        goto error;
 +    }
 +
 +    ret = 0;
 +
 +error:
 +    return ret;
 +}
 +
 +static enum CodecID waveform_codec_id(enum AVSampleFormat sample_fmt)
 +{
 +    switch (sample_fmt) {
 +    case AV_SAMPLE_FMT_U8:  return CODEC_ID_PCM_U8;
 +    case AV_SAMPLE_FMT_S16: return CODEC_ID_PCM_S16LE;
 +    case AV_SAMPLE_FMT_S32: return CODEC_ID_PCM_S32LE;
 +    default:                return CODEC_ID_NONE; /* Should never happen. */
 +    }
 +}
 +
- dshow_add_device(AVFormatContext *avctx, AVFormatParameters *ap,
++static enum AVSampleFormat sample_fmt_bits_per_sample(int bits)
 +{
 +    switch (bits) {
 +    case 8:  return AV_SAMPLE_FMT_U8;
 +    case 16: return AV_SAMPLE_FMT_S16;
 +    case 32: return AV_SAMPLE_FMT_S32;
 +    default: return AV_SAMPLE_FMT_NONE; /* Should never happen. */
 +    }
 +}
 +
 +static int
- static int dshow_read_header(AVFormatContext *avctx, AVFormatParameters *ap)
++dshow_add_device(AVFormatContext *avctx,
 +                 enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    AM_MEDIA_TYPE type;
 +    AVCodecContext *codec;
 +    AVStream *st;
 +    int ret = AVERROR(EIO);
 +
 +    st = avformat_new_stream(avctx, NULL);
 +    if (!st) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +    st->id = devtype;
 +
 +    ctx->capture_filter[devtype]->stream_index = st->index;
 +
 +    libAVPin_ConnectionMediaType(ctx->capture_pin[devtype], &type);
 +
 +    codec = st->codec;
 +    if (devtype == VideoDevice) {
 +        BITMAPINFOHEADER *bih = NULL;
 +
 +        if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo)) {
 +            VIDEOINFOHEADER *v = (void *) type.pbFormat;
 +            bih = &v->bmiHeader;
 +        } else if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo2)) {
 +            VIDEOINFOHEADER2 *v = (void *) type.pbFormat;
 +            bih = &v->bmiHeader;
 +        }
 +        if (!bih) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
 +            goto error;
 +        }
 +
 +        codec->time_base  = ap->time_base;
 +        codec->codec_type = AVMEDIA_TYPE_VIDEO;
 +        codec->width      = bih->biWidth;
 +        codec->height     = bih->biHeight;
 +        codec->pix_fmt    = dshow_pixfmt(bih->biCompression, bih->biBitCount);
 +        if (codec->pix_fmt == PIX_FMT_NONE) {
 +            codec->codec_id = dshow_codecid(bih->biCompression);
 +            if (codec->codec_id == CODEC_ID_NONE) {
 +                av_log(avctx, AV_LOG_ERROR, "Unknown compression type. "
 +                                 "Please report verbose (-v 9) debug information.\n");
 +                dshow_read_close(avctx);
 +                return AVERROR_PATCHWELCOME;
 +            }
 +            codec->bits_per_coded_sample = bih->biBitCount;
 +        } else {
 +            codec->codec_id = CODEC_ID_RAWVIDEO;
 +            if (bih->biCompression == BI_RGB || bih->biCompression == BI_BITFIELDS) {
 +                codec->bits_per_coded_sample = bih->biBitCount;
 +                codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);
 +                if (codec->extradata) {
 +                    codec->extradata_size = 9;
 +                    memcpy(codec->extradata, "BottomUp", 9);
 +                }
 +            }
 +        }
 +    } else {
 +        WAVEFORMATEX *fx = NULL;
 +
 +        if (IsEqualGUID(&type.formattype, &FORMAT_WaveFormatEx)) {
 +            fx = (void *) type.pbFormat;
 +        }
 +        if (!fx) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
 +            goto error;
 +        }
 +
 +        codec->codec_type  = AVMEDIA_TYPE_AUDIO;
 +        codec->sample_fmt  = sample_fmt_bits_per_sample(fx->wBitsPerSample);
 +        codec->codec_id    = waveform_codec_id(codec->sample_fmt);
 +        codec->sample_rate = fx->nSamplesPerSec;
 +        codec->channels    = fx->nChannels;
 +    }
 +
 +    avpriv_set_pts_info(st, 64, 1, 10000000);
 +
 +    ret = 0;
 +
 +error:
 +    return ret;
 +}
 +
 +static int parse_device_name(AVFormatContext *avctx)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    char **device_name = ctx->device_name;
 +    char *name = av_strdup(avctx->filename);
 +    char *tmp = name;
 +    int ret = 1;
 +    char *type;
 +
 +    while ((type = strtok(tmp, "="))) {
 +        char *token = strtok(NULL, ":");
 +        tmp = NULL;
 +
 +        if        (!strcmp(type, "video")) {
 +            device_name[0] = token;
 +        } else if (!strcmp(type, "audio")) {
 +            device_name[1] = token;
 +        } else {
 +            device_name[0] = NULL;
 +            device_name[1] = NULL;
 +            break;
 +        }
 +    }
 +
 +    if (!device_name[0] && !device_name[1]) {
 +        ret = 0;
 +    } else {
 +        if (device_name[0])
 +            device_name[0] = av_strdup(device_name[0]);
 +        if (device_name[1])
 +            device_name[1] = av_strdup(device_name[1]);
 +    }
 +
 +    av_free(name);
 +    return ret;
 +}
 +
++static int dshow_read_header(AVFormatContext *avctx)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IGraphBuilder *graph = NULL;
 +    ICreateDevEnum *devenum = NULL;
 +    IMediaControl *control = NULL;
 +    int ret = AVERROR(EIO);
 +    int r;
 +
 +    if (!ctx->list_devices && !parse_device_name(avctx)) {
 +        av_log(avctx, AV_LOG_ERROR, "Malformed dshow input string.\n");
 +        goto error;
 +    }
 +
 +    if (ctx->video_size) {
 +        r = av_parse_video_size(&ctx->requested_width, &ctx->requested_height, ctx->video_size);
 +        if (r < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not parse video size '%s'.\n", ctx->video_size);
 +            goto error;
 +        }
 +    }
 +    if (ctx->framerate) {
 +        r = av_parse_video_rate(&ctx->requested_framerate, ctx->framerate);
 +        if (r < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", ctx->framerate);
 +            goto error;
 +        }
 +    }
 +
 +    CoInitialize(0);
 +
 +    r = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
 +                         &IID_IGraphBuilder, (void **) &graph);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create capture graph.\n");
 +        goto error;
 +    }
 +    ctx->graph = graph;
 +
 +    r = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
 +                         &IID_ICreateDevEnum, (void **) &devenum);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate system devices.\n");
 +        goto error;
 +    }
 +
 +    if (ctx->list_devices) {
 +        av_log(avctx, AV_LOG_INFO, "DirectShow video devices\n");
 +        dshow_cycle_devices(avctx, devenum, VideoDevice, NULL);
 +        av_log(avctx, AV_LOG_INFO, "DirectShow audio devices\n");
 +        dshow_cycle_devices(avctx, devenum, AudioDevice, NULL);
 +        ret = AVERROR_EXIT;
 +        goto error;
 +    }
 +    if (ctx->list_options) {
 +        if (ctx->device_name[VideoDevice])
 +            dshow_list_device_options(avctx, devenum, VideoDevice);
 +        if (ctx->device_name[AudioDevice])
 +            dshow_list_device_options(avctx, devenum, AudioDevice);
 +        ret = AVERROR_EXIT;
 +        goto error;
 +    }
 +
 +    if (ctx->device_name[VideoDevice]) {
 +        ret = dshow_open_device(avctx, devenum, VideoDevice);
 +        if (ret < 0)
 +            goto error;
 +        ret = dshow_add_device(avctx, ap, VideoDevice);
 +        if (ret < 0)
 +            goto error;
 +    }
 +    if (ctx->device_name[AudioDevice]) {
 +        ret = dshow_open_device(avctx, devenum, AudioDevice);
 +        if (ret < 0)
 +            goto error;
 +        ret = dshow_add_device(avctx, ap, AudioDevice);
 +        if (ret < 0)
 +            goto error;
 +    }
 +
 +    ctx->mutex = CreateMutex(NULL, 0, NULL);
 +    if (!ctx->mutex) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create Mutex\n");
 +        goto error;
 +    }
 +    ctx->event = CreateEvent(NULL, 1, 0, NULL);
 +    if (!ctx->event) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create Event\n");
 +        goto error;
 +    }
 +
 +    r = IGraphBuilder_QueryInterface(graph, &IID_IMediaControl, (void **) &control);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not get media control.\n");
 +        goto error;
 +    }
 +    ctx->control = control;
 +
 +    r = IMediaControl_Run(control);
 +    if (r == S_FALSE) {
 +        OAFilterState pfs;
 +        r = IMediaControl_GetState(control, 0, &pfs);
 +    }
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not run filter\n");
 +        goto error;
 +    }
 +
 +    ret = 0;
 +
 +error:
 +
 +    if (ret < 0)
 +        dshow_read_close(avctx);
 +
 +    if (devenum)
 +        ICreateDevEnum_Release(devenum);
 +
 +    return ret;
 +}
 +
 +static int dshow_read_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList *pktl = NULL;
 +
 +    while (!pktl) {
 +        WaitForSingleObject(ctx->mutex, INFINITE);
 +        pktl = ctx->pktl;
 +        if (ctx->pktl) {
 +            *pkt = ctx->pktl->pkt;
 +            ctx->pktl = ctx->pktl->next;
 +            av_free(pktl);
 +        }
 +        ResetEvent(ctx->event);
 +        ReleaseMutex(ctx->mutex);
 +        if (!pktl) {
 +            if (s->flags & AVFMT_FLAG_NONBLOCK) {
 +                return AVERROR(EAGAIN);
 +            } else {
 +                WaitForSingleObject(ctx->event, INFINITE);
 +            }
 +        }
 +    }
 +
 +    ctx->curbufsize -= pkt->size;
 +
 +    return pkt->size;
 +}
 +
 +#define OFFSET(x) offsetof(struct dshow_ctx, x)
 +#define DEC AV_OPT_FLAG_DECODING_PARAM
 +static const AVOption options[] = {
 +    { "video_size", "set video size given a string such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 +    { "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 +    { "sample_rate", "set audio sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "sample_size", "set audio sample size", OFFSET(sample_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 16, DEC },
 +    { "channels", "set number of audio channels, such as 1 or 2", OFFSET(channels), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "list_devices", "list available devices", OFFSET(list_devices), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, DEC, "list_devices" },
 +    { "true", "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, DEC, "list_devices" },
 +    { "false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, DEC, "list_devices" },
 +    { "list_options", "list available options for specified device", OFFSET(list_options), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, DEC, "list_options" },
 +    { "true", "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, DEC, "list_options" },
 +    { "false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, DEC, "list_options" },
 +    { "video_device_number", "set video device number for devices with same name (starts at 0)", OFFSET(video_device_number), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "audio_device_number", "set audio device number for devices with same name (starts at 0)", OFFSET(audio_device_number), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { NULL },
 +};
 +
 +static const AVClass dshow_class = {
 +    .class_name = "DirectShow indev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVInputFormat ff_dshow_demuxer = {
 +    "dshow",
 +    NULL_IF_CONFIG_SMALL("DirectShow capture"),
 +    sizeof(struct dshow_ctx),
 +    NULL,
 +    dshow_read_header,
 +    dshow_read_packet,
 +    dshow_read_close,
 +    .flags = AVFMT_NOFILE,
 +    .priv_class = &dshow_class,
 +};
Simple merge
Simple merge
Simple merge
index c4a0654,0000000..30c08e0
mode 100644,000000..100644
--- /dev/null
@@@ -1,360 -1,0 +1,360 @@@
- av_cold static int lavfi_read_header(AVFormatContext *avctx,
-                                      AVFormatParameters *ap)
 +/*
 + * Copyright (c) 2011 Stefano Sabatini
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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
 + */
 +
 +/**
 + * @file
 + * libavfilter virtual input device
 + */
 +
 +/* #define DEBUG */
 +
 +#include "float.h"              /* DBL_MIN, DBL_MAX */
 +
 +#include "libavutil/log.h"
 +#include "libavutil/mem.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/parseutils.h"
 +#include "libavutil/pixdesc.h"
++#include "libavutil/audioconvert.h"
 +#include "libavfilter/avfilter.h"
 +#include "libavfilter/avfiltergraph.h"
 +#include "libavfilter/buffersink.h"
 +#include "libavformat/internal.h"
 +#include "avdevice.h"
 +
 +typedef struct {
 +    AVClass *class;          ///< class for private options
 +    char          *graph_str;
 +    char          *dump_graph;
 +    AVFilterGraph *graph;
 +    AVFilterContext **sinks;
 +    int *sink_stream_map;
 +    int *stream_sink_map;
 +} LavfiContext;
 +
 +static int *create_all_formats(int n)
 +{
 +    int i, j, *fmts, count = 0;
 +
 +    for (i = 0; i < n; i++)
 +        if (!(av_pix_fmt_descriptors[i].flags & PIX_FMT_HWACCEL))
 +            count++;
 +
 +    if (!(fmts = av_malloc((count+1) * sizeof(int))))
 +        return NULL;
 +    for (j = 0, i = 0; i < n; i++) {
 +        if (!(av_pix_fmt_descriptors[i].flags & PIX_FMT_HWACCEL))
 +            fmts[j++] = i;
 +    }
 +    fmts[j] = -1;
 +    return fmts;
 +}
 +
 +av_cold static int lavfi_read_close(AVFormatContext *avctx)
 +{
 +    LavfiContext *lavfi = avctx->priv_data;
 +
 +    av_freep(&lavfi->sink_stream_map);
 +    av_freep(&lavfi->stream_sink_map);
 +    av_freep(&lavfi->sinks);
 +    avfilter_graph_free(&lavfi->graph);
 +
 +    return 0;
 +}
 +
++av_cold static int lavfi_read_header(AVFormatContext *avctx)
 +{
 +    LavfiContext *lavfi = avctx->priv_data;
 +    AVFilterInOut *input_links = NULL, *output_links = NULL, *inout;
 +    AVFilter *buffersink, *abuffersink;
 +    int *pix_fmts = create_all_formats(PIX_FMT_NB);
 +    enum AVMediaType type;
 +    int ret = 0, i, n;
 +
 +#define FAIL(ERR) { ret = ERR; goto end; }
 +
 +    if (!pix_fmts)
 +        FAIL(AVERROR(ENOMEM));
 +
 +    avfilter_register_all();
 +
 +    buffersink = avfilter_get_by_name("buffersink");
 +    abuffersink = avfilter_get_by_name("abuffersink");
 +
 +    if (!lavfi->graph_str)
 +        lavfi->graph_str = av_strdup(avctx->filename);
 +
 +    /* parse the graph, create a stream for each open output */
 +    if (!(lavfi->graph = avfilter_graph_alloc()))
 +        FAIL(AVERROR(ENOMEM));
 +
 +    if ((ret = avfilter_graph_parse(lavfi->graph, lavfi->graph_str,
 +                                    &input_links, &output_links, avctx)) < 0)
 +        FAIL(ret);
 +
 +    if (input_links) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "Open inputs in the filtergraph are not acceptable\n");
 +        FAIL(AVERROR(EINVAL));
 +    }
 +
 +    /* count the outputs */
 +    for (n = 0, inout = output_links; inout; n++, inout = inout->next);
 +
 +    if (!(lavfi->sink_stream_map = av_malloc(sizeof(int) * n)))
 +        FAIL(AVERROR(ENOMEM));
 +    if (!(lavfi->stream_sink_map = av_malloc(sizeof(int) * n)))
 +        FAIL(AVERROR(ENOMEM));
 +
 +    for (i = 0; i < n; i++)
 +        lavfi->stream_sink_map[i] = -1;
 +
 +    /* parse the output link names - they need to be of the form out0, out1, ...
 +     * create a mapping between them and the streams */
 +    for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
 +        int stream_idx;
 +        if (!strcmp(inout->name, "out"))
 +            stream_idx = 0;
 +        else if (sscanf(inout->name, "out%d\n", &stream_idx) != 1) {
 +            av_log(avctx,  AV_LOG_ERROR,
 +                   "Invalid outpad name '%s'\n", inout->name);
 +            FAIL(AVERROR(EINVAL));
 +        }
 +
 +        if ((unsigned)stream_idx >= n) {
 +            av_log(avctx, AV_LOG_ERROR,
 +                   "Invalid index was specified in output '%s', "
 +                   "must be a non-negative value < %d\n",
 +                   inout->name, n);
 +            FAIL(AVERROR(EINVAL));
 +        }
 +
 +        /* is an audio or video output? */
 +        type = inout->filter_ctx->output_pads[inout->pad_idx].type;
 +        if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
 +            av_log(avctx,  AV_LOG_ERROR,
 +                   "Output '%s' is not a video or audio output, not yet supported\n", inout->name);
 +            FAIL(AVERROR(EINVAL));
 +        }
 +
 +        if (lavfi->stream_sink_map[stream_idx] != -1) {
 +            av_log(avctx,  AV_LOG_ERROR,
 +                   "An output with stream index %d was already specified\n",
 +                   stream_idx);
 +            FAIL(AVERROR(EINVAL));
 +        }
 +        lavfi->sink_stream_map[i] = stream_idx;
 +        lavfi->stream_sink_map[stream_idx] = i;
 +    }
 +
 +    /* for each open output create a corresponding stream */
 +    for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
 +        AVStream *st;
 +        if (!(st = avformat_new_stream(avctx, NULL)))
 +            FAIL(AVERROR(ENOMEM));
 +        st->id = i;
 +    }
 +
 +    /* create a sink for each output and connect them to the graph */
 +    lavfi->sinks = av_malloc(sizeof(AVFilterContext *) * avctx->nb_streams);
 +    if (!lavfi->sinks)
 +        FAIL(AVERROR(ENOMEM));
 +
 +    for (i = 0, inout = output_links; inout; i++, inout = inout->next) {
 +        AVFilterContext *sink;
 +
 +        type = inout->filter_ctx->output_pads[inout->pad_idx].type;
 +
 +        if (type == AVMEDIA_TYPE_VIDEO && ! buffersink ||
 +            type == AVMEDIA_TYPE_AUDIO && ! abuffersink) {
 +                av_log(avctx, AV_LOG_ERROR, "Missing required buffersink filter, aborting.\n");
 +                FAIL(AVERROR_FILTER_NOT_FOUND);
 +        }
 +
 +        if (type == AVMEDIA_TYPE_VIDEO) {
 +            AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 +
 +#if FF_API_OLD_VSINK_API
 +            ret = avfilter_graph_create_filter(&sink, buffersink,
 +                                               inout->name, NULL,
 +                                               pix_fmts, lavfi->graph);
 +#else
 +            buffersink_params->pixel_fmts = pix_fmts;
 +            ret = avfilter_graph_create_filter(&sink, buffersink,
 +                                               inout->name, NULL,
 +                                               buffersink_params, lavfi->graph);
 +#endif
 +            av_freep(&buffersink_params);
 +
 +            if (ret < 0)
 +                goto end;
 +        } else if (type == AVMEDIA_TYPE_AUDIO) {
 +            enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, -1 };
 +            const int packing_fmts[] = { AVFILTER_PACKED, -1 };
 +            const int64_t *chlayouts = avfilter_all_channel_layouts;
 +            AVABufferSinkParams *abuffersink_params = av_abuffersink_params_alloc();
 +            abuffersink_params->sample_fmts = sample_fmts;
 +            abuffersink_params->packing_fmts = packing_fmts;
 +            abuffersink_params->channel_layouts = chlayouts;
 +
 +            ret = avfilter_graph_create_filter(&sink, abuffersink,
 +                                               inout->name, NULL,
 +                                               abuffersink_params, lavfi->graph);
 +            av_free(abuffersink_params);
 +            if (ret < 0)
 +                goto end;
 +        }
 +
 +        lavfi->sinks[i] = sink;
 +        if ((ret = avfilter_link(inout->filter_ctx, inout->pad_idx, sink, 0)) < 0)
 +            FAIL(ret);
 +    }
 +
 +    /* configure the graph */
 +    if ((ret = avfilter_graph_config(lavfi->graph, avctx)) < 0)
 +        FAIL(ret);
 +
 +    if (lavfi->dump_graph) {
 +        char *dump = avfilter_graph_dump(lavfi->graph, lavfi->dump_graph);
 +        fputs(dump, stderr);
 +        fflush(stderr);
 +        av_free(dump);
 +    }
 +
 +    /* fill each stream with the information in the corresponding sink */
 +    for (i = 0; i < avctx->nb_streams; i++) {
 +        AVFilterLink *link = lavfi->sinks[lavfi->stream_sink_map[i]]->inputs[0];
 +        AVStream *st = avctx->streams[i];
 +        st->codec->codec_type = link->type;
 +        avpriv_set_pts_info(st, 64, link->time_base.num, link->time_base.den);
 +        if (link->type == AVMEDIA_TYPE_VIDEO) {
 +            st->codec->codec_id   = CODEC_ID_RAWVIDEO;
 +            st->codec->pix_fmt    = link->format;
 +            st->codec->time_base  = link->time_base;
 +            st->codec->width      = link->w;
 +            st->codec->height     = link->h;
 +            st       ->sample_aspect_ratio =
 +            st->codec->sample_aspect_ratio = link->sample_aspect_ratio;
 +        } else if (link->type == AVMEDIA_TYPE_AUDIO) {
 +            st->codec->codec_id    = CODEC_ID_PCM_S16LE;
 +            st->codec->channels    = av_get_channel_layout_nb_channels(link->channel_layout);
 +            st->codec->sample_fmt  = link->format;
 +            st->codec->sample_rate = link->sample_rate;
 +            st->codec->time_base   = link->time_base;
 +            st->codec->channel_layout = link->channel_layout;
 +        }
 +    }
 +
 +end:
 +    av_free(pix_fmts);
 +    avfilter_inout_free(&input_links);
 +    avfilter_inout_free(&output_links);
 +    if (ret < 0)
 +        lavfi_read_close(avctx);
 +    return ret;
 +}
 +
 +static int lavfi_read_packet(AVFormatContext *avctx, AVPacket *pkt)
 +{
 +    LavfiContext *lavfi = avctx->priv_data;
 +    double min_pts = DBL_MAX;
 +    int stream_idx, min_pts_sink_idx = 0;
 +    AVFilterBufferRef *ref;
 +    AVPicture pict;
 +    int ret, i;
 +    int size = 0;
 +
 +    /* iterate through all the graph sinks. Select the sink with the
 +     * minimum PTS */
 +    for (i = 0; i < avctx->nb_streams; i++) {
 +        AVRational tb = lavfi->sinks[i]->inputs[0]->time_base;
 +        double d;
 +        int ret = av_buffersink_get_buffer_ref(lavfi->sinks[i],
 +                                               &ref, AV_BUFFERSINK_FLAG_PEEK);
 +        if (ret < 0)
 +            return ret;
 +        d = av_rescale_q(ref->pts, tb, AV_TIME_BASE_Q);
 +        av_dlog(avctx, "sink_idx:%d time:%f\n", i, d);
 +
 +        if (d < min_pts) {
 +            min_pts = d;
 +            min_pts_sink_idx = i;
 +        }
 +    }
 +    av_dlog(avctx, "min_pts_sink_idx:%i\n", min_pts_sink_idx);
 +
 +    av_buffersink_get_buffer_ref(lavfi->sinks[min_pts_sink_idx], &ref, 0);
 +    stream_idx = lavfi->sink_stream_map[min_pts_sink_idx];
 +
 +    if (ref->video) {
 +        size = avpicture_get_size(ref->format, ref->video->w, ref->video->h);
 +        if ((ret = av_new_packet(pkt, size)) < 0)
 +            return ret;
 +
 +        memcpy(pict.data,     ref->data,     4*sizeof(ref->data[0]));
 +        memcpy(pict.linesize, ref->linesize, 4*sizeof(ref->linesize[0]));
 +
 +        avpicture_layout(&pict, ref->format, ref->video->w,
 +                         ref->video->h, pkt->data, size);
 +    } else if (ref->audio) {
 +        size = ref->audio->nb_samples *
 +            av_get_bytes_per_sample(ref->format) *
 +            av_get_channel_layout_nb_channels(ref->audio->channel_layout);
 +        if ((ret = av_new_packet(pkt, size)) < 0)
 +            return ret;
 +        memcpy(pkt->data, ref->data[0], size);
 +    }
 +
 +    pkt->stream_index = stream_idx;
 +    pkt->pts = ref->pts;
 +    pkt->pos = ref->pos;
 +    pkt->size = size;
 +    avfilter_unref_buffer(ref);
 +
 +    return size;
 +}
 +
 +#define OFFSET(x) offsetof(LavfiContext, x)
 +
 +#define DEC AV_OPT_FLAG_DECODING_PARAM
 +
 +static const AVOption options[] = {
 +    { "graph", "Libavfilter graph", OFFSET(graph_str),  AV_OPT_TYPE_STRING, {.str = NULL }, 0,  0, DEC },
 +    { "dumpgraph", "Dump graph to stderr", OFFSET(dump_graph), AV_OPT_TYPE_STRING, {.str = NULL}, 0,  0, DEC },
 +    { NULL },
 +};
 +
 +static const AVClass lavfi_class = {
 +    .class_name = "lavfi indev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVInputFormat ff_lavfi_demuxer = {
 +    .name           = "lavfi",
 +    .long_name      = NULL_IF_CONFIG_SMALL("Libavfilter virtual input device"),
 +    .priv_data_size = sizeof(LavfiContext),
 +    .read_header    = lavfi_read_header,
 +    .read_packet    = lavfi_read_packet,
 +    .read_close     = lavfi_read_close,
 +    .flags          = AVFMT_NOFILE,
 +    .priv_class     = &lavfi_class,
 +};
Simple merge
@@@ -2,11 -2,10 +2,10 @@@
   * IIDC1394 grab interface (uses libdc1394 and libraw1394)
   * Copyright (c) 2004 Roman Shaposhnik
   * Copyright (c) 2008 Alessandro Sappia
-  * Copyright (c) 2011 Martin Lambers
   *
 - * 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.
index 17256ca,0000000..2227d63
mode 100644,000000..100644
--- /dev/null
@@@ -1,251 -1,0 +1,251 @@@
- static int read_header(AVFormatContext *ctx, AVFormatParameters *ap)
 +/*
 + * Copyright (c) 2011 Jonathan Baldwin
 + *
 + * This file is part of FFmpeg.
 + *
 + * Permission to use, copy, modify, and/or distribute this software for any
 + * purpose with or without fee is hereby granted, provided that the above
 + * copyright notice and this permission notice appear in all copies.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 + * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 + * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 + * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 + * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 + * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 + * PERFORMANCE OF THIS SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * OpenAL 1.1 capture device for libavdevice
 + **/
 +
 +#include <AL/al.h>
 +#include <AL/alc.h>
 +
 +#include "libavutil/opt.h"
 +#include "libavformat/internal.h"
 +#include "avdevice.h"
 +
 +typedef struct {
 +    AVClass *class;
 +    /** OpenAL capture device context. **/
 +    ALCdevice *device;
 +    /** The number of channels in the captured audio. **/
 +    int channels;
 +    /** The sample rate (in Hz) of the captured audio. **/
 +    int sample_rate;
 +    /** The sample size (in bits) of the captured audio. **/
 +    int sample_size;
 +    /** The OpenAL sample format of the captured audio. **/
 +    ALCenum sample_format;
 +    /** The number of bytes between two consecutive samples of the same channel/component. **/
 +    ALCint sample_step;
 +    /** If true, print a list of capture devices on this system and exit. **/
 +    int list_devices;
 +} al_data;
 +
 +typedef struct {
 +    ALCenum al_fmt;
 +    enum CodecID codec_id;
 +    int channels;
 +} al_format_info;
 +
 +#define LOWEST_AL_FORMAT FFMIN(FFMIN(AL_FORMAT_MONO8,AL_FORMAT_MONO16),FFMIN(AL_FORMAT_STEREO8,AL_FORMAT_STEREO16))
 +
 +/**
 + * Get information about an AL_FORMAT value.
 + * @param al_fmt the AL_FORMAT value to find information about.
 + * @return A pointer to a structure containing information about the AL_FORMAT value.
 + */
 +static inline al_format_info* get_al_format_info(ALCenum al_fmt)
 +{
 +    static al_format_info info_table[] = {
 +        [AL_FORMAT_MONO8-LOWEST_AL_FORMAT]    = {AL_FORMAT_MONO8, CODEC_ID_PCM_U8, 1},
 +        [AL_FORMAT_MONO16-LOWEST_AL_FORMAT]   = {AL_FORMAT_MONO16, AV_NE (CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE), 1},
 +        [AL_FORMAT_STEREO8-LOWEST_AL_FORMAT]  = {AL_FORMAT_STEREO8, CODEC_ID_PCM_U8, 2},
 +        [AL_FORMAT_STEREO16-LOWEST_AL_FORMAT] = {AL_FORMAT_STEREO16, AV_NE (CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE), 2},
 +    };
 +
 +    return &info_table[al_fmt-LOWEST_AL_FORMAT];
 +}
 +
 +/**
 + * Get the OpenAL error code, translated into an av/errno error code.
 + * @param device The ALC device to check for errors.
 + * @param error_msg_ret A pointer to a char* in which to return the error message, or NULL if desired.
 + * @return The error code, or 0 if there is no error.
 + */
 +static inline int al_get_error(ALCdevice *device, const char** error_msg_ret)
 +{
 +    ALCenum error = alcGetError(device);
 +    if (error_msg_ret)
 +        *error_msg_ret = (const char*) alcGetString(device, error);
 +    switch (error) {
 +    case ALC_NO_ERROR:
 +        return 0;
 +    case ALC_INVALID_DEVICE:
 +        return AVERROR(ENODEV);
 +        break;
 +    case ALC_INVALID_CONTEXT:
 +    case ALC_INVALID_ENUM:
 +    case ALC_INVALID_VALUE:
 +        return AVERROR(EINVAL);
 +        break;
 +    case ALC_OUT_OF_MEMORY:
 +        return AVERROR(ENOMEM);
 +        break;
 +    default:
 +        return AVERROR(EIO);
 +    }
 +}
 +
 +/**
 + * Print out a list of OpenAL capture devices on this system.
 + */
 +static inline void print_al_capture_devices(void *log_ctx)
 +{
 +    const char *devices;
 +
 +    if (!(devices = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)))
 +        return;
 +
 +    av_log(log_ctx, AV_LOG_INFO, "List of OpenAL capture devices on this system:\n");
 +
 +    for (; *devices != '\0'; devices += strlen(devices) + 1)
 +        av_log(log_ctx, AV_LOG_INFO, "  %s\n", devices);
 +}
 +
++static int read_header(AVFormatContext *ctx)
 +{
 +    al_data *ad = ctx->priv_data;
 +    static const ALCenum sample_formats[2][2] = {
 +        { AL_FORMAT_MONO8,  AL_FORMAT_STEREO8  },
 +        { AL_FORMAT_MONO16, AL_FORMAT_STEREO16 }
 +    };
 +    int error = 0;
 +    const char *error_msg;
 +    AVStream *st = NULL;
 +    AVCodecContext *codec = NULL;
 +
 +    if (ad->list_devices) {
 +        print_al_capture_devices(ctx);
 +        return AVERROR_EXIT;
 +    }
 +
 +    ad->sample_format = sample_formats[ad->sample_size/8-1][ad->channels-1];
 +
 +    /* Open device for capture */
 +    ad->device =
 +        alcCaptureOpenDevice(ctx->filename[0] ? ctx->filename : NULL,
 +                             ad->sample_rate,
 +                             ad->sample_format,
 +                             ad->sample_rate); /* Maximum 1 second of sample data to be read at once */
 +
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    /* Create stream */
 +    if (!(st = avformat_new_stream(ctx, NULL))) {
 +        error = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    /* We work in microseconds */
 +    avpriv_set_pts_info(st, 64, 1, 1000000);
 +
 +    /* Set codec parameters */
 +    codec = st->codec;
 +    codec->codec_type = AVMEDIA_TYPE_AUDIO;
 +    codec->sample_rate = ad->sample_rate;
 +    codec->channels = get_al_format_info(ad->sample_format)->channels;
 +    codec->codec_id = get_al_format_info(ad->sample_format)->codec_id;
 +
 +    /* This is needed to read the audio data */
 +    ad->sample_step = (av_get_bits_per_sample(get_al_format_info(ad->sample_format)->codec_id) *
 +                       get_al_format_info(ad->sample_format)->channels) / 8;
 +
 +    /* Finally, start the capture process */
 +    alcCaptureStart(ad->device);
 +
 +    return 0;
 +
 +fail:
 +    /* Handle failure */
 +    if (ad->device)
 +        alcCaptureCloseDevice(ad->device);
 +    if (error_msg)
 +        av_log(ctx, AV_LOG_ERROR, "Cannot open device: %s\n", error_msg);
 +    return error;
 +}
 +
 +static int read_packet(AVFormatContext* ctx, AVPacket *pkt)
 +{
 +    al_data *ad = ctx->priv_data;
 +    int error=0;
 +    const char *error_msg;
 +    ALCint nb_samples;
 +
 +    /* Get number of samples available */
 +    alcGetIntegerv(ad->device, ALC_CAPTURE_SAMPLES, (ALCsizei) sizeof(ALCint), &nb_samples);
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    /* Create a packet of appropriate size */
 +    av_new_packet(pkt, nb_samples*ad->sample_step);
 +    pkt->pts = av_gettime();
 +
 +    /* Fill the packet with the available samples */
 +    alcCaptureSamples(ad->device, pkt->data, nb_samples);
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    return pkt->size;
 +fail:
 +    /* Handle failure */
 +    if (pkt->data)
 +        av_destruct_packet(pkt);
 +    if (error_msg)
 +        av_log(ctx, AV_LOG_ERROR, "Error: %s\n", error_msg);
 +    return error;
 +}
 +
 +static int read_close(AVFormatContext* ctx)
 +{
 +    al_data *ad = ctx->priv_data;
 +
 +    if (ad->device) {
 +        alcCaptureStop(ad->device);
 +        alcCaptureCloseDevice(ad->device);
 +    }
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(al_data, x)
 +
 +static const AVOption options[] = {
 +    {"channels", "set number of channels",     OFFSET(channels),     AV_OPT_TYPE_INT, {.dbl=2},     1, 2,      AV_OPT_FLAG_DECODING_PARAM },
 +    {"sample_rate", "set sample rate",         OFFSET(sample_rate),  AV_OPT_TYPE_INT, {.dbl=44100}, 1, 192000, AV_OPT_FLAG_DECODING_PARAM },
 +    {"sample_size", "set sample size",         OFFSET(sample_size),  AV_OPT_TYPE_INT, {.dbl=16},    8, 16,     AV_OPT_FLAG_DECODING_PARAM },
 +    {"list_devices", "list available devices", OFFSET(list_devices), AV_OPT_TYPE_INT, {.dbl=0},     0, 1,      AV_OPT_FLAG_DECODING_PARAM, "list_devices"  },
 +    {"true",  "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
 +    {"false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
 +    {NULL},
 +};
 +
 +static const AVClass class = {
 +    .class_name = "openal",
 +    .item_name = av_default_item_name,
 +    .option = options,
 +    .version = LIBAVUTIL_VERSION_INT
 +};
 +
 +AVInputFormat ff_openal_demuxer = {
 +    .name = "openal",
 +    .long_name = NULL_IF_CONFIG_SMALL("OpenAL audio capture device"),
 +    .priv_data_size = sizeof(al_data),
 +    .read_probe = NULL,
 +    .read_header = read_header,
 +    .read_packet = read_packet,
 +    .read_close = read_close,
 +    .flags = AVFMT_NOFILE,
 +    .priv_class = &class
 +};
Simple merge
Simple merge
Simple merge
@@@ -770,7 -766,7 +770,7 @@@ static int v4l2_read_header(AVFormatCon
  
      s->frame_format = desired_format;
  
-     if ((res = v4l2_set_parameters(s1, ap)) < 0)
 -    if ((res = v4l2_set_parameters(s1) < 0))
++    if ((res = v4l2_set_parameters(s1)) < 0)
          goto out;
  
      st->codec->pix_fmt = fmt_v4l2ff(desired_format, codec_id);
Simple merge
Simple merge
index 50d3fa1,0000000..162f57a
mode 100644,000000..100644
--- /dev/null
@@@ -1,150 -1,0 +1,150 @@@
 +/*
 + * This file is part of MPlayer.
 + *
 + * MPlayer is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License as published by
 + * the Free Software Foundation; either version 2 of the License, or
 + * (at your option) any later version.
 + *
 + * MPlayer 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 General Public License for more details.
 + *
 + * You should have received a copy of the GNU General Public License along
 + * with MPlayer; if not, write to the Free Software Foundation, Inc.,
 + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 + */
 +
 +#ifndef MPLAYER_MP_IMAGE_H
 +#define MPLAYER_MP_IMAGE_H
 +
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <string.h>
 +#undef printf //FIXME
 +#undef fprintf //FIXME
 +#include "mp_msg.h"
 +#include "libavutil/avutil.h"
 +#include "libavutil/avassert.h"
 +#undef realloc
 +#undef malloc
 +#undef free
 +#undef rand
 +#undef srand
 +#undef printf
 +#undef strncpy
 +#define ASMALIGN(ZEROBITS) ".p2align " #ZEROBITS "\n\t"
++#define CODEC_FLAG2_MEMC_ONLY     0x00001000 ///< Only do ME/MC (I frames -> ref, P frame -> ME+MC).
 +
 +//--------- codec's requirements (filled by the codec/vf) ---------
 +
 +//--- buffer content restrictions:
 +// set if buffer content shouldn't be modified:
 +#define MP_IMGFLAG_PRESERVE 0x01
 +// set if buffer content will be READ for next frame's MC: (I/P mpeg frames)
 +#define MP_IMGFLAG_READABLE 0x02
 +
 +//--- buffer width/stride/plane restrictions: (used for direct rendering)
 +// stride _have_to_ be aligned to MB boundary:  [for DR restrictions]
 +#define MP_IMGFLAG_ACCEPT_ALIGNED_STRIDE 0x4
 +// stride should be aligned to MB boundary:     [for buffer allocation]
 +#define MP_IMGFLAG_PREFER_ALIGNED_STRIDE 0x8
 +// codec accept any stride (>=width):
 +#define MP_IMGFLAG_ACCEPT_STRIDE 0x10
 +// codec accept any width (width*bpp=stride -> stride%bpp==0) (>=width):
 +#define MP_IMGFLAG_ACCEPT_WIDTH 0x20
 +//--- for planar formats only:
 +// uses only stride[0], and stride[1]=stride[2]=stride[0]>>mpi->chroma_x_shift
 +#define MP_IMGFLAG_COMMON_STRIDE 0x40
 +// uses only planes[0], and calculates planes[1,2] from width,height,imgfmt
 +#define MP_IMGFLAG_COMMON_PLANE 0x80
 +
 +#define MP_IMGFLAGMASK_RESTRICTIONS 0xFF
 +
 +//--------- color info (filled by mp_image_setfmt() ) -----------
 +// set if number of planes > 1
 +#define MP_IMGFLAG_PLANAR 0x100
 +// set if it's YUV colorspace
 +#define MP_IMGFLAG_YUV 0x200
 +// set if it's swapped (BGR or YVU) plane/byteorder
 +#define MP_IMGFLAG_SWAPPED 0x400
 +// set if you want memory for palette allocated and managed by vf_get_image etc.
 +#define MP_IMGFLAG_RGB_PALETTE 0x800
 +
 +#define MP_IMGFLAGMASK_COLORS 0xF00
 +
 +// codec uses drawing/rendering callbacks (draw_slice()-like thing, DR method 2)
 +// [the codec will set this flag if it supports callbacks, and the vo _may_
 +//  clear it in get_image() if draw_slice() not implemented]
 +#define MP_IMGFLAG_DRAW_CALLBACK 0x1000
 +// set if it's in video buffer/memory: [set by vo/vf's get_image() !!!]
 +#define MP_IMGFLAG_DIRECT 0x2000
 +// set if buffer is allocated (used in destination images):
 +#define MP_IMGFLAG_ALLOCATED 0x4000
 +
 +// buffer type was printed (do NOT set this flag - it's for INTERNAL USE!!!)
 +#define MP_IMGFLAG_TYPE_DISPLAYED 0x8000
 +
 +// codec doesn't support any form of direct rendering - it has own buffer
 +// allocation. so we just export its buffer pointers:
 +#define MP_IMGTYPE_EXPORT 0
 +// codec requires a static WO buffer, but it does only partial updates later:
 +#define MP_IMGTYPE_STATIC 1
 +// codec just needs some WO memory, where it writes/copies the whole frame to:
 +#define MP_IMGTYPE_TEMP 2
 +// I+P type, requires 2+ independent static R/W buffers
 +#define MP_IMGTYPE_IP 3
 +// I+P+B type, requires 2+ independent static R/W and 1+ temp WO buffers
 +#define MP_IMGTYPE_IPB 4
 +// Upper 16 bits give desired buffer number, -1 means get next available
 +#define MP_IMGTYPE_NUMBERED 5
 +// Doesn't need any buffer, incomplete image (probably a first field only)
 +// we need this type to be able to differentiate between half frames and
 +// all other cases
 +#define MP_IMGTYPE_INCOMPLETE 6
 +
 +#define MP_MAX_PLANES 4
 +
 +#define MP_IMGFIELD_ORDERED 0x01
 +#define MP_IMGFIELD_TOP_FIRST 0x02
 +#define MP_IMGFIELD_REPEAT_FIRST 0x04
 +#define MP_IMGFIELD_TOP 0x08
 +#define MP_IMGFIELD_BOTTOM 0x10
 +#define MP_IMGFIELD_INTERLACED 0x20
 +
 +typedef struct mp_image {
 +    unsigned int flags;
 +    unsigned char type;
 +    int number;
 +    unsigned char bpp;  // bits/pixel. NOT depth! for RGB it will be n*8
 +    unsigned int imgfmt;
 +    int width,height;  // stored dimensions
 +    int x,y,w,h;  // visible dimensions
 +    unsigned char* planes[MP_MAX_PLANES];
 +    int stride[MP_MAX_PLANES];
 +    char * qscale;
 +    int qstride;
 +    int pict_type; // 0->unknown, 1->I, 2->P, 3->B
 +    int fields;
 +    int qscale_type; // 0->mpeg1/4/h263, 1->mpeg2
 +    int num_planes;
 +    /* these are only used by planar formats Y,U(Cb),V(Cr) */
 +    int chroma_width;
 +    int chroma_height;
 +    int chroma_x_shift; // horizontal
 +    int chroma_y_shift; // vertical
 +    int usage_count;
 +    /* for private use by filter or vo driver (to store buffer id or dmpi) */
 +    void* priv;
 +} mp_image_t;
 +
 +void mp_image_setfmt(mp_image_t* mpi,unsigned int out_fmt);
 +mp_image_t* new_mp_image(int w,int h);
 +void free_mp_image(mp_image_t* mpi);
 +
 +mp_image_t* alloc_mpi(int w, int h, unsigned long int fmt);
 +void mp_image_alloc_planes(mp_image_t *mpi);
 +void copy_mpi(mp_image_t *dmpi, mp_image_t *mpi);
 +
 +#endif /* MPLAYER_MP_IMAGE_H */
Simple merge
Simple merge
index 5c414f0,0000000..e47afc1
mode 100644,000000..100644
--- /dev/null
@@@ -1,208 -1,0 +1,207 @@@
- static int read_header(AVFormatContext *s,
-                            AVFormatParameters *ap)
 +/*
 + * ACT file format demuxer
 + * Copyright (c) 2007-2008 Vladimir Voroshilov
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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 "avformat.h"
 +#include "riff.h"
 +#include "internal.h"
 +#include "libavcodec/get_bits.h"
 +
 +#define CHUNK_SIZE 512
 +#define RIFF_TAG MKTAG('R','I','F','F')
 +#define WAVE_TAG MKTAG('W','A','V','E')
 +
 +typedef struct{
 +    int bytes_left_in_chunk;
 +    uint8_t audio_buffer[22];///< temporary buffer for ACT frame
 +    char second_packet;      ///< 1 - if temporary buffer contains valid (second) G.729 packet
 +} ACTContext;
 +
 +static int probe(AVProbeData *p)
 +{
 +    int i;
 +
 +    if ((AV_RL32(&p->buf[0]) != RIFF_TAG) ||
 +        (AV_RL32(&p->buf[8]) != WAVE_TAG) ||
 +        (AV_RL32(&p->buf[16]) != 16))
 +    return 0;
 +
 +    //We cant be sure that this is ACT and not regular WAV
 +    if (p->buf_size<512)
 +        return 0;
 +
 +    for(i=44; i<256; i++)
 +        if(p->buf[i])
 +            return 0;
 +
 +    if(p->buf[256]!=0x84)
 +        return 0;
 +
 +    for(i=264; i<512; i++)
 +        if(p->buf[i])
 +            return 0;
 +
 +    return AVPROBE_SCORE_MAX;
 +}
 +
++static int read_header(AVFormatContext *s)
 +{
 +    ACTContext* ctx = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +    int size;
 +    AVStream* st;
 +
 +    int min,sec,msec;
 +
 +    st = avformat_new_stream(s, NULL);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +
 +    avio_skip(pb, 16);
 +    size=avio_rl32(pb);
 +    ff_get_wav_header(pb, st->codec, size);
 +
 +    /*
 +      8000Hz (Fine-rec) file format has 10 bytes long
 +      packets with 10ms of sound data in them
 +    */
 +    if (st->codec->sample_rate != 8000) {
 +        av_log(s, AV_LOG_ERROR, "Sample rate %d is not supported.\n", st->codec->sample_rate);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    st->codec->frame_size=80;
 +    st->codec->channels=1;
 +    avpriv_set_pts_info(st, 64, 1, 100);
 +
 +    st->codec->codec_id=CODEC_ID_G729;
 +
 +    avio_seek(pb, 257, SEEK_SET);
 +    msec=avio_rl16(pb);
 +    sec=avio_r8(pb);
 +    min=avio_rl32(pb);
 +
 +    st->duration = av_rescale(1000*(min*60+sec)+msec, st->codec->sample_rate, 1000 * st->codec->frame_size);
 +
 +    ctx->bytes_left_in_chunk=CHUNK_SIZE;
 +
 +    avio_seek(pb, 512, SEEK_SET);
 +
 +    return 0;
 +}
 +
 +
 +static int read_packet(AVFormatContext *s,
 +                          AVPacket *pkt)
 +{
 +    ACTContext *ctx = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +    int ret;
 +    int frame_size=s->streams[0]->codec->sample_rate==8000?10:22;
 +
 +
 +    if(s->streams[0]->codec->sample_rate==8000)
 +        ret=av_new_packet(pkt, 10);
 +    else
 +        ret=av_new_packet(pkt, 11);
 +
 +    if(ret)
 +        return ret;
 +
 +    if(s->streams[0]->codec->sample_rate==4400 && !ctx->second_packet)
 +    {
 +        ret = avio_read(pb, ctx->audio_buffer, frame_size);
 +
 +        if(ret<0)
 +            return ret;
 +        if(ret!=frame_size)
 +            return AVERROR(EIO);
 +
 +        pkt->data[0]=ctx->audio_buffer[11];
 +        pkt->data[1]=ctx->audio_buffer[0];
 +        pkt->data[2]=ctx->audio_buffer[12];
 +        pkt->data[3]=ctx->audio_buffer[1];
 +        pkt->data[4]=ctx->audio_buffer[13];
 +        pkt->data[5]=ctx->audio_buffer[2];
 +        pkt->data[6]=ctx->audio_buffer[14];
 +        pkt->data[7]=ctx->audio_buffer[3];
 +        pkt->data[8]=ctx->audio_buffer[15];
 +        pkt->data[9]=ctx->audio_buffer[4];
 +        pkt->data[10]=ctx->audio_buffer[16];
 +
 +        ctx->second_packet=1;
 +    }
 +    else if(s->streams[0]->codec->sample_rate==4400 && ctx->second_packet)
 +    {
 +        pkt->data[0]=ctx->audio_buffer[5];
 +        pkt->data[1]=ctx->audio_buffer[17];
 +        pkt->data[2]=ctx->audio_buffer[6];
 +        pkt->data[3]=ctx->audio_buffer[18];
 +        pkt->data[4]=ctx->audio_buffer[7];
 +        pkt->data[5]=ctx->audio_buffer[19];
 +        pkt->data[6]=ctx->audio_buffer[8];
 +        pkt->data[7]=ctx->audio_buffer[20];
 +        pkt->data[8]=ctx->audio_buffer[9];
 +        pkt->data[9]=ctx->audio_buffer[21];
 +        pkt->data[10]=ctx->audio_buffer[10];
 +
 +        ctx->second_packet=0;
 +    }
 +    else // 8000 Hz
 +    {
 +        ret = avio_read(pb, ctx->audio_buffer, frame_size);
 +
 +        if(ret<0)
 +            return ret;
 +        if(ret!=frame_size)
 +            return AVERROR(EIO);
 +
 +        pkt->data[0]=ctx->audio_buffer[5];
 +        pkt->data[1]=ctx->audio_buffer[0];
 +        pkt->data[2]=ctx->audio_buffer[6];
 +        pkt->data[3]=ctx->audio_buffer[1];
 +        pkt->data[4]=ctx->audio_buffer[7];
 +        pkt->data[5]=ctx->audio_buffer[2];
 +        pkt->data[6]=ctx->audio_buffer[8];
 +        pkt->data[7]=ctx->audio_buffer[3];
 +        pkt->data[8]=ctx->audio_buffer[9];
 +        pkt->data[9]=ctx->audio_buffer[4];
 +    }
 +
 +    ctx->bytes_left_in_chunk -= frame_size;
 +
 +    if(ctx->bytes_left_in_chunk < frame_size)
 +    {
 +        avio_skip(pb, ctx->bytes_left_in_chunk);
 +        ctx->bytes_left_in_chunk=CHUNK_SIZE;
 +    }
 +
 +    pkt->duration=1;
 +
 +    return ret;
 +}
 +
 +AVInputFormat ff_act_demuxer = {
 +    .name           = "act",
 +    .long_name      = "ACT Voice file format",
 +    .priv_data_size = sizeof(ACTContext),
 +    .read_probe     = probe,
 +    .read_header    = read_header,
 +    .read_packet    = read_packet,
 +};
Simple merge
@@@ -70,20 -69,19 +70,20 @@@ static int get_tag(AVIOContext *pb, uin
  static void get_meta(AVFormatContext *s, const char *key, int size)
  {
      uint8_t *str = av_malloc(size+1);
 -    int res;
  
 -    if (!str) {
 -        avio_skip(s->pb, size);
 -        return;
 -    }
 -
 -    res = avio_read(s->pb, str, size);
 -    if (res < 0)
 -        return;
 +    if (str) {
 +        int res = avio_read(s->pb, str, size);
 +        if (res < 0){
 +            av_free(str);
 +            return;
 +        }
 +        size += (size&1)-res;
 +        str[res] = 0;
-         av_dict_set(&s->metadata, key, str, AV_METADATA_DONT_STRDUP_VAL);
++        av_dict_set(&s->metadata, key, str, AV_DICT_DONT_STRDUP_VAL);
 +    }else
 +        size+= size&1;
  
 -    str[res] = 0;
 -    av_dict_set(&s->metadata, key, str, AV_DICT_DONT_STRDUP_VAL);
 +    avio_skip(s->pb, size);
  }
  
  /* Returns the number of sound data frames or negative on error */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -118,10 -118,9 +118,9 @@@ static int au_probe(AVProbeData *p
  }
  
  /* au input */
- static int au_read_header(AVFormatContext *s,
-                           AVFormatParameters *ap)
+ static int au_read_header(AVFormatContext *s)
  {
 -    int size;
 +    int size, bps, data_size = 0;
      unsigned int tag;
      AVIOContext *pb = s->pb;
      unsigned int id, channels, rate;
@@@ -422,9 -332,9 +335,6 @@@ typedef struct AVOutputFormat 
       * AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH
       */
      int flags;
-     void *dummy;
 -    /**
 -     * Currently only used to set pixel format if not YUV420P.
 -     */
      int (*interleave_packet)(struct AVFormatContext *, AVPacket *out,
                               AVPacket *in, int flush);
  
@@@ -667,26 -555,10 +563,10 @@@ typedef struct AVStream 
       * encoding: set by libavformat in av_write_header
       */
      AVRational time_base;
- #if FF_API_REORDER_PRIVATE
-     int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
- #endif
- #if FF_API_STREAM_COPY
-     /* ffmpeg.c private use */
-     attribute_deprecated int stream_copy; /**< If set, just copy stream. */
- #endif
      enum AVDiscard discard; ///< Selects which packets can be discarded at will and do not need to be demuxed.
  
- #if FF_API_AVSTREAM_QUALITY
-     //FIXME move stuff to a flags field?
-     /**
-      * Quality, as it has been removed from AVCodecContext and put in AVVideoFrame.
-      * MN: dunno if that is the right place for it
-      */
-     attribute_deprecated float quality;
- #endif
      /**
 -     * Decoding: pts of the first frame of the stream, in stream time base.
 +     * Decoding: pts of the first frame of the stream in presentation order, in stream time base.
       * Only set this if you are absolutely 100% sure that the value you set
       * it to really is the pts of the first frame.
       * This may be undefined (AV_NOPTS_VALUE).
      unsigned int index_entries_allocated_size;
  
      int pts_wrap_bits; /**< number of bits in pts (used for wrapping control) */
- #endif
++
++    /**
++     * flag to indicate that probing is requested
++     * NOT PART OF PUBLIC API
++     */
++    int request_probe;
  } AVStream;
  
  #define AV_PROGRAM_RUNNING 1
@@@ -1032,23 -776,9 +806,13 @@@ typedef struct AVFormatContext 
  #define AVFMT_FLAG_IGNDTS       0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
  #define AVFMT_FLAG_NOFILLIN     0x0010 ///< Do not infer any values from other values, just return what is stored in the container
  #define AVFMT_FLAG_NOPARSE      0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
- #if FF_API_FLAG_RTP_HINT
- #define AVFMT_FLAG_RTP_HINT     0x0040 ///< Deprecated, use the -movflags rtphint muxer specific AVOption instead
- #endif
  #define AVFMT_FLAG_CUSTOM_IO    0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
  #define AVFMT_FLAG_DISCARD_CORRUPT  0x0100 ///< Discard frames marked corrupted
 +#define AVFMT_FLAG_MP4A_LATM    0x8000 ///< Enable RTP MP4A-LATM payload
 +#define AVFMT_FLAG_SORT_DTS    0x10000 ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
 +#define AVFMT_FLAG_PRIV_OPT    0x20000 ///< Enable use of private options by delaying codec open (this could be made default once all code is converted)
 +#define AVFMT_FLAG_KEEP_SIDE_DATA 0x40000 ///< Dont merge side data but keep it seperate.
  
- #if FF_API_LOOP_INPUT
-     /**
-      * @deprecated, use the 'loop' img2 demuxer private option.
-      */
-     attribute_deprecated int loop_input;
- #endif
      /**
       * decoding: size of data to probe; encoding: unused.
       */
@@@ -1354,46 -1030,6 +1094,41 @@@ AVProgram *av_new_program(AVFormatConte
   */
  
  
- #if FF_API_GUESS_IMG2_CODEC
- attribute_deprecated enum CodecID av_guess_image2_codec(const char *filename);
- #endif
 +#if FF_API_PKT_DUMP
 +attribute_deprecated void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
 +attribute_deprecated void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt,
 +                                          int dump_payload);
 +#endif
 +
 +#if FF_API_ALLOC_OUTPUT_CONTEXT
 +/**
 + * @deprecated deprecated in favor of avformat_alloc_output_context2()
 + */
 +attribute_deprecated
 +AVFormatContext *avformat_alloc_output_context(const char *format,
 +                                               AVOutputFormat *oformat,
 +                                               const char *filename);
 +#endif
 +
 +/**
 + * Allocate an AVFormatContext for an output format.
 + * avformat_free_context() can be used to free the context and
 + * everything allocated by the framework within it.
 + *
 + * @param *ctx is set to the created format context, or to NULL in
 + * case of failure
 + * @param oformat format to use for allocating the context, if NULL
 + * format_name and filename are used instead
 + * @param format_name the name of output format to use for allocating the
 + * context, if NULL filename is used instead
 + * @param filename the name of the filename to use for allocating the
 + * context, may be NULL
 + * @return >= 0 in case of success, a negative AVERROR code in case of
 + * failure
 + */
 +int avformat_alloc_output_context2(AVFormatContext **ctx, AVOutputFormat *oformat,
 +                                   const char *format_name, const char *filename);
 +
  /**
   * @addtogroup lavf_decoding
   * @{
@@@ -1504,28 -1101,6 +1209,29 @@@ int av_probe_input_buffer(AVIOContext *
   */
  int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options);
  
- int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap);
++attribute_deprecated
++int av_demuxer_open(AVFormatContext *ic);
 +
 +#if FF_API_FORMAT_PARAMETERS
 +/**
 + * Read packets of a media file to get stream information. This
 + * is useful for file formats with no headers such as MPEG. This
 + * function also computes the real framerate in case of MPEG-2 repeat
 + * frame mode.
 + * The logical file position is not changed by this function;
 + * examined packets may be buffered for later processing.
 + *
 + * @param ic media file handle
 + * @return >=0 if OK, AVERROR_xxx on error
 + * @todo Let the user decide somehow what information is needed so that
 + *       we do not waste time getting stuff the user does not need.
 + *
 + * @deprecated use avformat_find_stream_info.
 + */
 +attribute_deprecated
 +int av_find_stream_info(AVFormatContext *ic);
 +#endif
 +
  /**
   * Read packets of a media file to get stream information. This
   * is useful for file formats with no headers such as MPEG. This
@@@ -693,33 -663,11 +693,33 @@@ static int avi_read_header(AVFormatCont
                  }
              }
              break;
 +        case MKTAG('s', 't', 'r', 'd'):
 +            if (stream_index >= (unsigned)s->nb_streams || s->streams[stream_index]->codec->extradata_size) {
 +                avio_skip(pb, size);
 +            } else {
 +                uint64_t cur_pos = avio_tell(pb);
 +                if (cur_pos < list_end)
 +                    size = FFMIN(size, list_end - cur_pos);
 +                st = s->streams[stream_index];
 +
 +                if(size<(1<<30)){
 +                    st->codec->extradata_size= size;
 +                    st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 +                    if (!st->codec->extradata) {
 +                        st->codec->extradata_size= 0;
 +                        return AVERROR(ENOMEM);
 +                    }
 +                    avio_read(pb, st->codec->extradata, st->codec->extradata_size);
 +                }
 +
 +                if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
 +                    avio_r8(pb);
 +            }
 +            break;
          case MKTAG('i', 'n', 'd', 'x'):
              i= avio_tell(pb);
 -            if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
 -               read_braindead_odml_indx(s, 0) < 0 &&
 -               (s->error_recognition & AV_EF_EXPLODE))
 +            if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) && avi->use_odml &&
-                read_braindead_odml_indx(s, 0) < 0 && s->error_recognition >= FF_ER_EXPLODE)
++               read_braindead_odml_indx(s, 0) < 0 && (s->error_recognition & AV_EF_EXPLODE))
                  goto fail;
              avio_seek(pb, i+size, SEEK_SET);
              break;
Simple merge
Simple merge
@@@ -265,24 -234,6 +234,11 @@@ int64_t avio_seek(AVIOContext *s, int64
      return offset;
  }
  
- #if FF_API_OLD_AVIO
- int url_fskip(AVIOContext *s, int64_t offset)
- {
-     int64_t ret = avio_seek(s, offset, SEEK_CUR);
-     return ret < 0 ? ret : 0;
- }
- int64_t url_ftell(AVIOContext *s)
- {
-     return avio_seek(s, 0, SEEK_CUR);
- }
- #endif
 +int64_t avio_skip(AVIOContext *s, int64_t offset)
 +{
 +    return avio_seek(s, offset, SEEK_CUR);
 +}
 +
  int64_t avio_size(AVIOContext *s)
  {
      int64_t size;
      return size;
  }
  
- #if FF_API_OLD_AVIO
- int url_ferror(AVIOContext *s)
- {
-     if(!s)
-         return 0;
-     return s->error;
- }
- #endif
 +int url_feof(AVIOContext *s)
 +{
 +    if(!s)
 +        return 0;
 +    if(s->eof_reached){
 +        s->eof_reached=0;
 +        fill_buffer(s);
 +    }
 +    return s->eof_reached;
 +}
 +
  void avio_wl32(AVIOContext *s, unsigned int val)
  {
      avio_w8(s, val);
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 1c84092,0000000..d9395f0
mode 100644,000000..100644
--- /dev/null
@@@ -1,376 -1,0 +1,371 @@@
- static AVStream * init_stream(AVFormatContext *s,
-                               AVFormatParameters *ap)
 +/*
 + * Binary text demuxer
 + * eXtended BINary text (XBIN) demuxer
 + * Artworx Data Format demuxer
 + * iCEDraw File demuxer
 + * Copyright (c) 2010 Peter Ross <pross@xvid.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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
 + */
 +
 +/**
 + * @file
 + * Binary text demuxer
 + * eXtended BINary text (XBIN) demuxer
 + * Artworx Data Format demuxer
 + * iCEDraw File demuxer
 + */
 +
 +#include "libavutil/intreadwrite.h"
 +#include "avformat.h"
 +#include "internal.h"
 +#include "sauce.h"
 +#include "libavcodec/bintext.h"
 +
 +#define LINE_RATE 6000 /** characters per second */
 +
 +typedef struct {
 +    int chars_per_frame;
 +    uint64_t fsize;  /**< file size less metadata buffer */
 +} BinDemuxContext;
 +
 +#if CONFIG_BINTEXT_DEMUXER | CONFIG_ADF_DEMUXER | CONFIG_IDF_DEMUXER
 +/**
 + * Given filesize and width, calculate height (assume font_height of 16)
 + */
 +static void calculate_height(AVCodecContext *avctx, uint64_t fsize)
 +{
 +    avctx->height = (fsize / ((avctx->width>>3)*2)) << 4;
 +}
 +#endif
 +
 +#if CONFIG_BINTEXT_DEMUXER
 +static const uint8_t next_magic[]={
 +    0x1A, 0x1B, '[', '0', ';', '3', '0', ';', '4', '0', 'm', 'N', 'E', 'X', 'T', 0x00
 +};
 +
 +static int next_tag_read(AVFormatContext *avctx, uint64_t *fsize)
 +{
 +    AVIOContext *pb = avctx->pb;
 +    char buf[36];
 +    int len;
 +    uint64_t start_pos = avio_size(pb) - 256;
 +
 +    avio_seek(pb, start_pos, SEEK_SET);
 +    if (avio_read(pb, buf, sizeof(next_magic)) != sizeof(next_magic))
 +        return -1;
 +    if (memcmp(buf, next_magic, sizeof(next_magic)))
 +        return -1;
 +    if (avio_r8(pb) != 0x01)
 +        return -1;
 +
 +    *fsize -= 256;
 +
 +#define GET_EFI2_META(name,size) \
 +    len = avio_r8(pb); \
 +    if (len < 1 || len > size) \
 +        return -1; \
 +    if (avio_read(pb, buf, size) == size && *buf) { \
 +        buf[len] = 0; \
 +        av_dict_set(&avctx->metadata, name, buf, 0); \
 +    }
 +
 +    GET_EFI2_META("filename",  12)
 +    GET_EFI2_META("author",    20)
 +    GET_EFI2_META("publisher", 20)
 +    GET_EFI2_META("title",     35)
 +
 +    return 0;
 +}
 +
 +static void predict_width(AVCodecContext *avctx, uint64_t fsize, int got_width)
 +{
 +    /** attempt to guess width */
 +    if (!got_width)
 +        avctx->width = fsize > 4000 ? (160<<3) : (80<<3);
 +}
 +
-     if (!ap->time_base.num) {
++static AVStream * init_stream(AVFormatContext *s)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +    AVStream *st = avformat_new_stream(s, NULL);
 +    if (!st)
 +        return NULL;
 +    st->codec->codec_tag   = 0;
 +    st->codec->codec_type  = AVMEDIA_TYPE_VIDEO;
 +
-     } else {
-         avpriv_set_pts_info(st, 60, ap->time_base.num, ap->time_base.den);
-     }
++//     if (!ap->time_base.num) {
 +        avpriv_set_pts_info(st, 60, 1, 25);
-     bin->chars_per_frame = FFMAX(av_q2d(st->time_base) * (ap->sample_rate ? ap->sample_rate : LINE_RATE), 1);
++//     } else {
++//         avpriv_set_pts_info(st, 60, ap->time_base.num, ap->time_base.den);
++//     }
 +
 +    /* simulate tty display speed */
-     st->codec->width  = ap->width  ? ap->width  : (80<<3);
-     st->codec->height = ap->height ? ap->height : (25<<4);
++    bin->chars_per_frame = FFMAX(av_q2d(st->time_base) * (/*ap->sample_rate ? ap->sample_rate :*/ LINE_RATE), 1);
 +
- static int bintext_read_header(AVFormatContext *s,
-                                AVFormatParameters *ap)
++    st->codec->width  = /*ap->width  ? ap->width  :*/ (80<<3);
++    st->codec->height = /*ap->height ? ap->height :*/ (25<<4);
 +    return st;
 +}
 +
-     AVStream *st = init_stream(s, ap);
++static int bintext_read_header(AVFormatContext *s)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +
-         if (!ap->width)
++    AVStream *st = init_stream(s);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +    st->codec->codec_id    = CODEC_ID_BINTEXT;
 +
 +    st->codec->extradata_size = 2;
 +    st->codec->extradata = av_malloc(st->codec->extradata_size);
 +    if (!st->codec->extradata)
 +        return AVERROR(ENOMEM);
 +    st->codec->extradata[0] = 16;
 +    st->codec->extradata[1] = 0;
 +
 +    if (pb->seekable) {
 +        int got_width = 0;
 +        bin->fsize = avio_size(pb);
 +        if (ff_sauce_read(s, &bin->fsize, &got_width, 0) < 0)
 +            next_tag_read(s, &bin->fsize);
-         if (!ap->height)
++//         if (!ap->width)
 +            predict_width(st->codec, bin->fsize, got_width);
- static int xbin_read_header(AVFormatContext *s,
-                            AVFormatParameters *ap)
++//         if (!ap->height)
 +            calculate_height(st->codec, bin->fsize);
 +        avio_seek(pb, 0, SEEK_SET);
 +    }
 +    return 0;
 +};
 +#endif /* CONFIG_BINTEXT_DEMUXER */
 +
 +#if CONFIG_XBIN_DEMUXER
 +static int xbin_probe(AVProbeData *p)
 +{
 +    const uint8_t *d = p->buf;
 +
 +    if (AV_RL32(d) == MKTAG('X','B','I','N') && d[4] == 0x1A &&
 +        AV_RL16(d+5) > 0 && AV_RL16(d+5) <= 160 &&
 +        d[9] > 0 && d[9] <= 32)
 +        return AVPROBE_SCORE_MAX;
 +    return 0;
 +}
 +
-     AVStream *st = init_stream(s, ap);
++static int xbin_read_header(AVFormatContext *s)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +    char fontheight, flags;
 +
- static int adf_read_header(AVFormatContext *s,
-                            AVFormatParameters *ap)
++    AVStream *st = init_stream(s);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +
 +    avio_skip(pb, 5);
 +    st->codec->width   = avio_rl16(pb)<<3;
 +    st->codec->height  = avio_rl16(pb);
 +    fontheight         = avio_r8(pb);
 +    st->codec->height *= fontheight;
 +    flags              = avio_r8(pb);
 +
 +    st->codec->extradata_size = 2;
 +    if ((flags & BINTEXT_PALETTE))
 +        st->codec->extradata_size += 48;
 +    if ((flags & BINTEXT_FONT))
 +        st->codec->extradata_size += fontheight * (flags & 0x10 ? 512 : 256);
 +    st->codec->codec_id    = flags & 4 ? CODEC_ID_XBIN : CODEC_ID_BINTEXT;
 +
 +    st->codec->extradata = av_malloc(st->codec->extradata_size);
 +    if (!st->codec->extradata)
 +        return AVERROR(ENOMEM);
 +    st->codec->extradata[0] = fontheight;
 +    st->codec->extradata[1] = flags;
 +    if (avio_read(pb, st->codec->extradata + 2, st->codec->extradata_size - 2) < 0)
 +        return AVERROR(EIO);
 +
 +    if (pb->seekable) {
 +        bin->fsize = avio_size(pb) - 9 - st->codec->extradata_size;
 +        ff_sauce_read(s, &bin->fsize, NULL, 0);
 +        avio_seek(pb, 9 + st->codec->extradata_size, SEEK_SET);
 +    }
 +
 +    return 0;
 +}
 +#endif /* CONFIG_XBIN_DEMUXER */
 +
 +#if CONFIG_ADF_DEMUXER
-     st = init_stream(s, ap);
++static int adf_read_header(AVFormatContext *s)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +    AVStream *st;
 +
 +    if (avio_r8(pb) != 1)
 +        return AVERROR_INVALIDDATA;
 +
-         if (!ap->height)
++    st = init_stream(s);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +    st->codec->codec_id    = CODEC_ID_BINTEXT;
 +
 +    st->codec->extradata_size = 2 + 48 + 4096;
 +    st->codec->extradata = av_malloc(st->codec->extradata_size);
 +    if (!st->codec->extradata)
 +        return AVERROR(ENOMEM);
 +    st->codec->extradata[0] = 16;
 +    st->codec->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
 +
 +    if (avio_read(pb, st->codec->extradata + 2, 24) < 0)
 +        return AVERROR(EIO);
 +    avio_skip(pb, 144);
 +    if (avio_read(pb, st->codec->extradata + 2 + 24, 24) < 0)
 +        return AVERROR(EIO);
 +    if (avio_read(pb, st->codec->extradata + 2 + 48, 4096) < 0)
 +        return AVERROR(EIO);
 +
 +    if (pb->seekable) {
 +        int got_width = 0;
 +        bin->fsize = avio_size(pb) - 1 - 192 - 4096;
 +        st->codec->width = 80<<3;
 +        ff_sauce_read(s, &bin->fsize, &got_width, 0);
- static int idf_read_header(AVFormatContext *s,
-                            AVFormatParameters *ap)
++//         if (!ap->height)
 +            calculate_height(st->codec, bin->fsize);
 +        avio_seek(pb, 1 + 192 + 4096, SEEK_SET);
 +    }
 +    return 0;
 +}
 +#endif /* CONFIG_ADF_DEMUXER */
 +
 +#if CONFIG_IDF_DEMUXER
 +static const uint8_t idf_magic[] = {
 +    0x04, 0x31, 0x2e, 0x34, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x00, 0x15, 0x00
 +};
 +
 +static int idf_probe(AVProbeData *p)
 +{
 +    if (p->buf_size < sizeof(idf_magic))
 +        return 0;
 +    if (!memcmp(p->buf, idf_magic, sizeof(idf_magic)))
 +        return AVPROBE_SCORE_MAX;
 +    return 0;
 +}
 +
-     st = init_stream(s, ap);
++static int idf_read_header(AVFormatContext *s)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +    AVIOContext *pb = s->pb;
 +    AVStream *st;
 +    int got_width = 0;
 +
 +    if (!pb->seekable)
 +        return AVERROR(EIO);
 +
-     if (!ap->height)
++    st = init_stream(s);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +    st->codec->codec_id    = CODEC_ID_IDF;
 +
 +    st->codec->extradata_size = 2 + 48 + 4096;
 +    st->codec->extradata = av_malloc(st->codec->extradata_size);
 +    if (!st->codec->extradata)
 +        return AVERROR(ENOMEM);
 +    st->codec->extradata[0] = 16;
 +    st->codec->extradata[1] = BINTEXT_PALETTE|BINTEXT_FONT;
 +
 +    avio_seek(pb, avio_size(pb) - 4096 - 48, SEEK_SET);
 +
 +    if (avio_read(pb, st->codec->extradata + 2 + 48, 4096) < 0)
 +        return AVERROR(EIO);
 +    if (avio_read(pb, st->codec->extradata + 2, 48) < 0)
 +        return AVERROR(EIO);
 +
 +    bin->fsize = avio_size(pb) - 12 - 4096 - 48;
 +    ff_sauce_read(s, &bin->fsize, &got_width, 0);
++//     if (!ap->height)
 +        calculate_height(st->codec, bin->fsize);
 +    avio_seek(pb, 12, SEEK_SET);
 +    return 0;
 +}
 +#endif /* CONFIG_IDF_DEMUXER */
 +
 +static int read_packet(AVFormatContext *s,
 +                           AVPacket *pkt)
 +{
 +    BinDemuxContext *bin = s->priv_data;
 +
 +    if (bin->fsize > 0) {
 +        if (av_get_packet(s->pb, pkt, bin->fsize) < 0)
 +            return AVERROR(EIO);
 +        bin->fsize = -1; /* done */
 +    } else if (!bin->fsize) {
 +        if (url_feof(s->pb))
 +            return AVERROR(EIO);
 +        if (av_get_packet(s->pb, pkt, bin->chars_per_frame) < 0)
 +            return AVERROR(EIO);
 +    } else {
 +        return AVERROR(EIO);
 +    }
 +
 +    pkt->flags |= AV_PKT_FLAG_KEY;
 +    return 0;
 +}
 +
 +#if CONFIG_BINTEXT_DEMUXER
 +AVInputFormat ff_bintext_demuxer = {
 +    .name           = "bin",
 +    .long_name      = NULL_IF_CONFIG_SMALL("Binary text"),
 +    .priv_data_size = sizeof(BinDemuxContext),
 +    .read_header    = bintext_read_header,
 +    .read_packet    = read_packet,
 +    .extensions     = "bin",
 +};
 +#endif
 +
 +#if CONFIG_XBIN_DEMUXER
 +AVInputFormat ff_xbin_demuxer = {
 +    .name           = "xbin",
 +    .long_name      = NULL_IF_CONFIG_SMALL("eXtended BINary text (XBIN)"),
 +    .priv_data_size = sizeof(BinDemuxContext),
 +    .read_probe     = xbin_probe,
 +    .read_header    = xbin_read_header,
 +    .read_packet    = read_packet,
 +};
 +#endif
 +
 +#if CONFIG_ADF_DEMUXER
 +AVInputFormat ff_adf_demuxer = {
 +    .name           = "adf",
 +    .long_name      = NULL_IF_CONFIG_SMALL("Artworx Data Format"),
 +    .priv_data_size = sizeof(BinDemuxContext),
 +    .read_header    = adf_read_header,
 +    .read_packet    = read_packet,
 +    .extensions     = "adf",
 +};
 +#endif
 +
 +#if CONFIG_IDF_DEMUXER
 +AVInputFormat ff_idf_demuxer = {
 +    .name           = "idf",
 +    .long_name      = NULL_IF_CONFIG_SMALL("iCE Draw File"),
 +    .priv_data_size = sizeof(BinDemuxContext),
 +    .read_probe     = idf_probe,
 +    .read_header    = idf_read_header,
 +    .read_packet    = read_packet,
 +    .extensions     = "idf",
 +};
 +#endif
index 1249ea1,0000000..b0931f4
mode 100644,000000..100644
--- /dev/null
@@@ -1,156 -1,0 +1,156 @@@
- static int read_header(AVFormatContext *s, AVFormatParameters *ap)
 +/*
 + * G.729 bit format muxer and demuxer
 + * Copyright (c) 2007-2008 Vladimir Voroshilov
 + *
 + * This file is part of FFmpeg.
 + *
 + * 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.
 + *
 + * 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 "avformat.h"
 +#include "internal.h"
 +#include "libavcodec/get_bits.h"
 +#include "libavcodec/put_bits.h"
 +
 +#define MAX_FRAME_SIZE 10
 +
 +#define SYNC_WORD  0x6b21
 +#define BIT_0      0x7f
 +#define BIT_1      0x81
 +
 +static int probe(AVProbeData *p)
 +{
 +    int i, j;
 +
 +    if(p->buf_size < 0x40)
 +        return 0;
 +
 +    for(i=0; i+3<p->buf_size && i< 10*0x50; ){
 +        if(AV_RL16(&p->buf[0]) != SYNC_WORD)
 +            return 0;
 +        j=AV_RL16(&p->buf[2]);
 +        if(j!=0x40 && j!=0x50)
 +            return 0;
 +        i+=j;
 +    }
 +    return AVPROBE_SCORE_MAX/2;
 +}
 +
++static int read_header(AVFormatContext *s)
 +{
 +    AVStream* st;
 +
 +    st=avformat_new_stream(s, NULL);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +
 +    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
 +    st->codec->codec_id=CODEC_ID_G729;
 +    st->codec->sample_rate=8000;
 +    st->codec->block_align = 16;
 +    st->codec->channels=1;
 +
 +    avpriv_set_pts_info(st, 64, 1, 100);
 +    return 0;
 +}
 +
 +static int read_packet(AVFormatContext *s,
 +                          AVPacket *pkt)
 +{
 +    AVIOContext *pb = s->pb;
 +    PutBitContext pbo;
 +    uint16_t buf[8 * MAX_FRAME_SIZE + 2];
 +    int packet_size;
 +    uint16_t* src=buf;
 +    int i, j, ret;
 +    int64_t pos= avio_tell(pb);
 +
 +    if(url_feof(pb))
 +        return AVERROR_EOF;
 +
 +    avio_rl16(pb); // sync word
 +    packet_size = avio_rl16(pb) / 8;
 +    if(packet_size > MAX_FRAME_SIZE)
 +        return AVERROR_INVALIDDATA;
 +
 +    ret = avio_read(pb, (uint8_t*)buf, (8 * packet_size) * sizeof(uint16_t));
 +    if(ret<0)
 +        return ret;
 +    if(ret != 8 * packet_size * sizeof(uint16_t))
 +        return AVERROR(EIO);
 +
 +    av_new_packet(pkt, packet_size);
 +
 +    init_put_bits(&pbo, pkt->data, packet_size);
 +    for(j=0; j < packet_size; j++)
 +        for(i=0; i<8;i++)
 +            put_bits(&pbo,1, AV_RL16(src++) == BIT_1 ? 1 : 0);
 +
 +    flush_put_bits(&pbo);
 +
 +    pkt->duration=1;
 +    pkt->pos = pos;
 +    return 0;
 +}
 +
 +AVInputFormat ff_bit_demuxer = {
 +    .name        = "bit",
 +    .long_name   = NULL_IF_CONFIG_SMALL("G.729 BIT file format"),
 +    .read_probe  = probe,
 +    .read_header = read_header,
 +    .read_packet = read_packet,
 +    .extensions  = "bit",
 +};
 +
 +#if CONFIG_MUXERS
 +static int write_header(AVFormatContext *s)
 +{
 +    AVCodecContext *enc = s->streams[0]->codec;
 +
 +    enc->codec_id = CODEC_ID_G729;
 +    enc->channels = 1;
 +    enc->bits_per_coded_sample = 16;
 +    enc->block_align = (enc->bits_per_coded_sample * enc->channels) >> 3;
 +
 +    return 0;
 +}
 +
 +static int write_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    AVIOContext *pb = s->pb;
 +    GetBitContext gb;
 +    int i;
 +
 +    avio_wl16(pb, SYNC_WORD);
 +    avio_wl16(pb, 8 * 10);
 +
 +    init_get_bits(&gb, pkt->data, 8*10);
 +    for(i=0; i< 8 * 10; i++)
 +        avio_wl16(pb, get_bits1(&gb) ? BIT_1 : BIT_0);
 +    avio_flush(pb);
 +
 +    return 0;
 +}
 +
 +AVOutputFormat ff_bit_muxer = {
 +    .name         = "bit",
 +    .long_name    = NULL_IF_CONFIG_SMALL("G.729 BIT file format"),
 +    .mime_type    = "audio/bit",
 +    .extensions   = "bit",
 +    .audio_codec  = CODEC_ID_G729,
 +    .video_codec  = CODEC_ID_NONE,
 +    .write_header = write_header,
 +    .write_packet = write_packet,
 +};
 +#endif
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -453,40 -402,7 +453,39 @@@ typedef struct RawDVContext 
      uint8_t         buf[DV_MAX_FRAME_SIZE];
  } RawDVContext;
  
- static int dv_read_header(AVFormatContext *s,
-                           AVFormatParameters *ap)
 +static int dv_read_timecode(AVFormatContext *s) {
 +    int ret;
 +    char timecode[32];
 +    int64_t pos = avio_tell(s->pb);
 +
 +    // Read 3 DIF blocks: Header block and 2 Subcode blocks.
 +    int partial_frame_size = 3 * 80;
 +    uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) *
 +                                        partial_frame_size);
 +
 +    RawDVContext *c = s->priv_data;
 +    ret = avio_read(s->pb, partial_frame, partial_frame_size);
 +    if (ret < 0)
 +        goto finish;
 +
 +    if (ret < partial_frame_size) {
 +        ret = -1;
 +        goto finish;
 +    }
 +
 +    ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode);
 +    if (ret)
 +        av_dict_set(&s->metadata, "timecode", timecode, 0);
 +    else if (ret < 0)
 +        av_log(s, AV_LOG_ERROR, "Detected timecode is invalid");
 +
 +finish:
 +    av_free(partial_frame);
 +    avio_seek(s->pb, pos, SEEK_SET);
 +    return ret;
 +}
 +
+ static int dv_read_header(AVFormatContext *s)
  {
      unsigned state, marker_pos = 0;
      RawDVContext *c = s->priv_data;
Simple merge
Simple merge
Simple merge
Simple merge