Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 21 Aug 2011 13:27:02 +0000 (15:27 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 21 Aug 2011 13:27:02 +0000 (15:27 +0200)
* qatar/master:
  WavPack demuxer: do not rely on index when timestamp is not in indexed range.
  WavPack demuxer: store position of the first block in index.
  WavPack decoder: implement flush function
  avconv: Separate initialization from the main transcode loop.

Conflicts:
avconv.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
avconv.c
libavcodec/wavpack.c
libavformat/wv.c

diff --combined avconv.c
+++ b/avconv.c
@@@ -1,21 -1,21 +1,21 @@@
  /*
 - * avconv main
 - * Copyright (c) 2000-2011 The libav developers.
 + * ffmpeg main
 + * Copyright (c) 2000-2003 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "libavutil/libm.h"
  #include "libavformat/os_support.h"
  
 +#include "libavformat/ffm.h" // not public API
 +
  #if CONFIG_AVFILTER
 +# include "libavfilter/avcodec.h"
  # include "libavfilter/avfilter.h"
  # include "libavfilter/avfiltergraph.h"
 +# include "libavfilter/vsink_buffer.h"
  # include "libavfilter/vsrc_buffer.h"
  #endif
  
  #include <sys/select.h>
  #endif
  
 +#if HAVE_TERMIOS_H
 +#include <fcntl.h>
 +#include <sys/ioctl.h>
 +#include <sys/time.h>
 +#include <termios.h>
 +#elif HAVE_KBHIT
 +#include <conio.h>
 +#endif
  #include <time.h>
  
  #include "cmdutils.h"
@@@ -102,14 -90,13 +102,14 @@@ typedef struct StreamMap 
   * select an input file for an output file
   */
  typedef struct MetadataMap {
 -    int  file;      //< file index
 -    char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 -    int  index;     //< stream/chapter/program number
 +    int  file;      ///< file index
 +    char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 +    int  index;     ///< stream/chapter/program number
  } MetadataMap;
  
  static const OptionDef options[];
  
 +#define MAX_STREAMS 1024    /* arbitrary sanity check value */
  static const char *last_asked_format = NULL;
  static AVDictionary *ts_scale;
  
@@@ -135,7 -122,6 +135,7 @@@ static int frame_width  = 0
  static int frame_height = 0;
  static float frame_aspect_ratio = 0;
  static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 +static int frame_bits_per_raw_sample = 0;
  static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
  static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
  static AVRational frame_rate;
@@@ -185,12 -171,12 +185,12 @@@ static int do_hex_dump = 0
  static int do_pkt_dump = 0;
  static int do_psnr = 0;
  static int do_pass = 0;
 -static char *pass_logfilename_prefix = NULL;
 +static const char *pass_logfilename_prefix;
  static int video_sync_method= -1;
  static int audio_sync_method= 0;
  static float audio_drift_threshold= 0.1;
  static int copy_ts= 0;
 -static int copy_tb;
 +static int copy_tb= 0;
  static int opt_shortest = 0;
  static char *vstats_filename;
  static FILE *vstats_file;
@@@ -204,9 -190,7 +204,9 @@@ static int audio_volume = 256
  static int exit_on_error = 0;
  static int using_stdin = 0;
  static int verbose = 1;
 +static int run_as_daemon  = 0;
  static int thread_count= 1;
 +static int q_pressed = 0;
  static int64_t video_size = 0;
  static int64_t audio_size = 0;
  static int64_t extra_size = 0;
@@@ -242,6 -226,7 +242,6 @@@ typedef struct InputStream 
      int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
                                  is not defined */
      int64_t       pts;       /* current pts */
 -    PtsCorrectionContext pts_ctx;
      double ts_scale;
      int is_start;            /* is 1 at the start and after a discontinuity */
      int showed_multi_packet_warning;
@@@ -253,7 -238,6 +253,7 @@@ typedef struct InputFile 
      int eof_reached;      /* true if eof reached */
      int ist_index;        /* index of first stream in ist_table */
      int buffer_size;      /* current total buffer size */
 +    int nb_streams;
      int64_t ts_offset;
  } InputFile;
  
@@@ -274,7 -258,7 +274,7 @@@ typedef struct OutputStream 
  
      /* video only */
      int video_resample;
 -    AVFrame pict_tmp;      /* temporary image for resampling */
 +    AVFrame resample_frame;              /* temporary frame for image resampling */
      struct SwsContext *img_resample_ctx; /* for image resampling */
      int resample_height;
      int resample_width;
     int is_past_recording_time;
  } OutputStream;
  
 +#if HAVE_TERMIOS_H
 +
 +/* init terminal so that we can grab keys */
 +static struct termios oldtty;
 +#endif
  
  typedef struct OutputFile {
      AVFormatContext *ctx;
@@@ -345,7 -324,7 +345,7 @@@ static int configure_video_filters(Inpu
      /** filter graph containing all filters including input & output */
      AVCodecContext *codec = ost->st->codec;
      AVCodecContext *icodec = ist->st->codec;
 -    FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 +    enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
      AVRational sample_aspect_ratio;
      char args[255];
      int ret;
                                         "src", args, NULL, ost->graph);
      if (ret < 0)
          return ret;
 -    ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
 -                                       "out", NULL, &ffsink_ctx, ost->graph);
 +    ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 +                                       "out", NULL, pix_fmts, ost->graph);
      if (ret < 0)
          return ret;
      last_filter = ost->input_video_filter;
      ost->graph->scale_sws_opts = av_strdup(args);
  
      if (ost->avfilter) {
 -        AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 -        AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 +        AVFilterInOut *outputs = avfilter_inout_alloc();
 +        AVFilterInOut *inputs  = avfilter_inout_alloc();
  
          outputs->name    = av_strdup("in");
          outputs->filter_ctx = last_filter;
          inputs->pad_idx = 0;
          inputs->next    = NULL;
  
 -        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
 +        if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
              return ret;
          av_freep(&ost->avfilter);
      } else {
  
  static void term_exit(void)
  {
 -    av_log(NULL, AV_LOG_QUIET, "");
 +    av_log(NULL, AV_LOG_QUIET, "%s", "");
 +#if HAVE_TERMIOS_H
 +    if(!run_as_daemon)
 +        tcsetattr (0, TCSANOW, &oldtty);
 +#endif
  }
  
  static volatile int received_sigterm = 0;
 -static volatile int received_nb_signals = 0;
  
  static void
  sigterm_handler(int sig)
  {
      received_sigterm = sig;
 -    received_nb_signals++;
 +    q_pressed++;
      term_exit();
  }
  
  static void term_init(void)
  {
 +#if HAVE_TERMIOS_H
 +    if(!run_as_daemon){
 +    struct termios tty;
 +
 +    tcgetattr (0, &tty);
 +    oldtty = tty;
 +    atexit(term_exit);
 +
 +    tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 +                          |INLCR|IGNCR|ICRNL|IXON);
 +    tty.c_oflag |= OPOST;
 +    tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 +    tty.c_cflag &= ~(CSIZE|PARENB);
 +    tty.c_cflag |= CS8;
 +    tty.c_cc[VMIN] = 1;
 +    tty.c_cc[VTIME] = 0;
 +
 +    tcsetattr (0, TCSANOW, &tty);
 +    signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 +    }
 +#endif
 +
      signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
      signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
  #ifdef SIGXCPU
  #endif
  }
  
 +/* read a key without blocking */
 +static int read_key(void)
 +{
 +#if HAVE_TERMIOS_H
 +    int n = 1;
 +    unsigned char ch;
 +    struct timeval tv;
 +    fd_set rfds;
 +
 +    if(run_as_daemon)
 +        return -1;
 +
 +    FD_ZERO(&rfds);
 +    FD_SET(0, &rfds);
 +    tv.tv_sec = 0;
 +    tv.tv_usec = 0;
 +    n = select(1, &rfds, NULL, NULL, &tv);
 +    if (n > 0) {
 +        n = read(0, &ch, 1);
 +        if (n == 1)
 +            return ch;
 +
 +        return n;
 +    }
 +#elif HAVE_KBHIT
 +    if(kbhit())
 +        return(getch());
 +#endif
 +    return -1;
 +}
 +
  static int decode_interrupt_cb(void)
  {
 -    return received_nb_signals > 1;
 +    q_pressed += read_key() == 'q';
 +    return q_pressed > 1;
  }
  
  static int exit_program(int ret)
@@@ -618,9 -540,6 +618,9 @@@ static void choose_sample_fmt(AVStream 
                  break;
          }
          if (*p == -1) {
 +            if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
 +                av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
 +            if(av_get_sample_fmt_name(st->codec->sample_fmt))
              av_log(NULL, AV_LOG_WARNING,
                     "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
                     av_get_sample_fmt_name(st->codec->sample_fmt),
      }
  }
  
 -/**
 - * Update the requested input sample format based on the output sample format.
 - * This is currently only used to request float output from decoders which
 - * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
 - * Ideally this will be removed in the future when decoders do not do format
 - * conversion and only output in their native format.
 - */
 -static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
 -                              AVCodecContext *enc)
 -{
 -    /* if sample formats match or a decoder sample format has already been
 -       requested, just return */
 -    if (enc->sample_fmt == dec->sample_fmt ||
 -        dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
 -        return;
 -
 -    /* if decoder supports more than one output format */
 -    if (dec_codec && dec_codec->sample_fmts &&
 -        dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
 -        dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
 -        const enum AVSampleFormat *p;
 -        int min_dec = -1, min_inc = -1;
 -
 -        /* find a matching sample format in the encoder */
 -        for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
 -            if (*p == enc->sample_fmt) {
 -                dec->request_sample_fmt = *p;
 -                return;
 -            } else if (*p > enc->sample_fmt) {
 -                min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
 -            } else
 -                min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
 -        }
 -
 -        /* if none match, provide the one that matches quality closest */
 -        dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
 -                                  enc->sample_fmt - min_dec;
 -    }
 -}
 -
  static void choose_sample_rate(AVStream *st, AVCodec *codec)
  {
      if(codec && codec->supported_samplerates){
@@@ -758,7 -717,7 +758,7 @@@ need_realloc
          exit_program(1);
      }
  
 -    if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
 +    if (enc->channels != dec->channels)
          ost->audio_resample = 1;
  
      resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
              ost->resample_sample_rate == enc->sample_rate) {
              ost->resample = NULL;
              ost->audio_resample = 0;
 -        } else if (ost->audio_resample) {
 +        } else {
              if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
                  fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
              ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
@@@ -1080,39 -1039,30 +1080,39 @@@ static void do_video_resample(OutputStr
                         ost->resample_height  != dec->height ||
                         ost->resample_pix_fmt != dec->pix_fmt;
  
 +#if !CONFIG_AVFILTER
      if (resample_changed) {
          av_log(NULL, AV_LOG_INFO,
                 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
                 ist->file_index, ist->st->index,
                 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
                 dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
 -        if(!ost->video_resample)
 -            ost->video_resample = 1;
 +        ost->resample_width   = dec->width;
 +        ost->resample_height  = dec->height;
 +        ost->resample_pix_fmt = dec->pix_fmt;
      }
  
 -#if !CONFIG_AVFILTER
 +    ost->video_resample = dec->width   != enc->width  ||
 +                          dec->height  != enc->height ||
 +                          dec->pix_fmt != enc->pix_fmt;
 +
      if (ost->video_resample) {
 -        *out_picture = &ost->pict_tmp;
 -        if (resample_changed) {
 +        *out_picture = &ost->resample_frame;
 +        if (!ost->img_resample_ctx || resample_changed) {
 +            /* initialize the destination picture */
 +            if (!ost->resample_frame.data[0]) {
 +                avcodec_get_frame_defaults(&ost->resample_frame);
 +                if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
 +                                    enc->width, enc->height)) {
 +                    fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
 +                    exit_program(1);
 +                }
 +            }
              /* initialize a new scaler context */
              sws_freeContext(ost->img_resample_ctx);
 -            ost->img_resample_ctx = sws_getContext(
 -                ist->st->codec->width,
 -                ist->st->codec->height,
 -                ist->st->codec->pix_fmt,
 -                ost->st->codec->width,
 -                ost->st->codec->height,
 -                ost->st->codec->pix_fmt,
 -                ost->sws_flags, NULL, NULL, NULL);
 +            ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
 +                                                   enc->width, enc->height, enc->pix_fmt,
 +                                                   ost->sws_flags, NULL, NULL, NULL);
              if (ost->img_resample_ctx == NULL) {
                  fprintf(stderr, "Cannot get resampling context\n");
                  exit_program(1);
@@@ -1327,8 -1277,7 +1327,8 @@@ static void print_report(OutputFile *ou
      int64_t total_size;
      AVCodecContext *enc;
      int frame_number, vid, i;
 -    double bitrate, ti1, pts;
 +    double bitrate;
 +    int64_t pts = INT64_MAX;
      static int64_t last_time = -1;
      static int qp_histogram[52];
  
          total_size= avio_tell(oc->pb);
  
      buf[0] = '\0';
 -    ti1 = 1e10;
      vid = 0;
      for(i=0;i<nb_ostreams;i++) {
          float q = -1;
              vid = 1;
          }
          /* compute min output value */
 -        pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
 -        if ((pts < ti1) && (pts > 0))
 -            ti1 = pts;
 +        pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
 +                                      ost->st->time_base, AV_TIME_BASE_Q));
      }
 -    if (ti1 < 0.01)
 -        ti1 = 0.01;
  
      if (verbose > 0 || is_last_report) {
 -        bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 +        int hours, mins, secs, us;
 +        secs = pts / AV_TIME_BASE;
 +        us = pts % AV_TIME_BASE;
 +        mins = secs / 60;
 +        secs %= 60;
 +        hours = mins / 60;
 +        mins %= 60;
 +
 +        bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
  
          snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 -            "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
 -            (double)total_size / 1024, ti1, bitrate);
 +                 "size=%8.0fkB time=", total_size / 1024.0);
 +        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 +                 "%02d:%02d:%02d.%02d ", hours, mins, secs,
 +                 (100 * us) / AV_TIME_BASE);
 +        snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 +                 "bitrate=%6.1fkbits/s", bitrate);
  
          if (nb_frames_dup || nb_frames_drop)
            snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
@@@ -1646,7 -1587,7 +1646,7 @@@ static int output_packet(InputStream *i
                          /* no picture yet */
                          goto discard_packet;
                      }
 -                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
 +                    ist->next_pts = ist->pts = picture.best_effort_timestamp;
                      if (ist->st->codec->time_base.num != 0) {
                          int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
                          ist->next_pts += ((int64_t)AV_TIME_BASE *
  #if CONFIG_AVFILTER
              if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
                  ost->input_video_filter) {
 -                AVRational sar;
 -                if (ist->st->sample_aspect_ratio.num)
 -                    sar = ist->st->sample_aspect_ratio;
 -                else
 -                    sar = ist->st->codec->sample_aspect_ratio;
 -                av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
 +                if (!picture.sample_aspect_ratio.num)
 +                    picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
 +                picture.pts = ist->pts;
 +
 +                av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
              }
              frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
                  !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
              while (frame_available) {
 -                AVRational ist_pts_tb;
 -                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
 -                    get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
 -                if (ost->picref)
 -                    ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
 +                if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
 +                    AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
 +                    if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
 +                        goto cont;
 +                    if (ost->picref) {
 +                        avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
 +                        ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
 +                    }
 +                }
  #endif
                  os = output_files[ost->file_index].ctx;
  
                      case AVMEDIA_TYPE_VIDEO:
  #if CONFIG_AVFILTER
                          if (ost->picref->video && !ost->frame_aspect_ratio)
 -                            ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
 +                            ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
  #endif
                          do_video_out(os, ost, ist, &picture, &frame_size,
 -                                     same_quant ? quality : ost->st->codec->global_quality);
 +                                        same_quant ? quality : ost->st->codec->global_quality);
                          if (vstats_filename && frame_size)
                              do_video_stats(os, ost, frame_size);
                          break;
                      }
                  } else {
                      AVFrame avframe; //FIXME/XXX remove this
 +                    AVPicture pict;
                      AVPacket opkt;
                      int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
 -
                      av_init_packet(&opkt);
  
                      if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
                          opkt.size = data_size;
                      }
  
 +                    if (os->oformat->flags & AVFMT_RAWPICTURE) {
 +                        /* store AVPicture in AVPacket, as expected by the output format */
 +                        avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
 +                        opkt.data = (uint8_t *)&pict;
 +                        opkt.size = sizeof(AVPicture);
 +                        opkt.flags |= AV_PKT_FLAG_KEY;
 +                    }
                      write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
                      ost->st->codec->frame_number++;
                      ost->frame_number++;
@@@ -1902,6 -1833,16 +1902,6 @@@ static int init_input_stream(int ist_in
              return AVERROR(EINVAL);
          }
  
 -        /* update requested sample format for the decoder based on the
 -           corresponding encoder sample format */
 -        for (i = 0; i < nb_output_streams; i++) {
 -            OutputStream *ost = &output_streams[i];
 -            if (ost->source_index == ist_index) {
 -                update_sample_fmt(ist->st->codec, codec, ost->st->codec);
 -                break;
 -            }
 -        }
 -
          if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
              snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
                      ist->file_index, ist->st->index);
  
      ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
      ist->next_pts = AV_NOPTS_VALUE;
 -    init_pts_correction(&ist->pts_ctx);
      ist->is_start = 1;
  
      return 0;
  }
  
- /*
-  * The following code is the main loop of the file converter
-  */
- static int transcode(OutputFile *output_files,
-                      int nb_output_files,
-                      InputFile *input_files,
-                      int nb_input_files)
+ static int transcode_init(OutputFile *output_files,
+                           int nb_output_files,
+                           InputFile *input_files,
+                           int nb_input_files)
  {
-     int ret = 0, i, step;
-     AVFormatContext *is, *os;
+     int ret = 0, i;
+     AVFormatContext *os;
      AVCodecContext *codec, *icodec;
      OutputStream *ost;
      InputStream *ist;
      char error[1024];
-     int key;
      int want_sdp = 1;
-     uint8_t *no_packet;
-     int no_packet_count=0;
-     int64_t timer_start;
-     if (!(no_packet = av_mallocz(nb_input_files)))
-         exit_program(1);
  
      if (rate_emu)
          for (i = 0; i < nb_input_streams; i++)
          if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
              av_dump_format(os, i, os->filename, 1);
              fprintf(stderr, "Output file #%d does not contain any stream\n", i);
-             ret = AVERROR(EINVAL);
-             goto fail;
+             return AVERROR(EINVAL);
          }
      }
  
              uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
  
              if (extra_size > INT_MAX) {
-                 ret = AVERROR(EINVAL);
-                 goto fail;
+                 return AVERROR(EINVAL);
              }
  
              /* if stream_copy is selected, no need to decode or encode */
              codec->rc_buffer_size = icodec->rc_buffer_size;
              codec->extradata= av_mallocz(extra_size);
              if (!codec->extradata) {
-                 ret = AVERROR(ENOMEM);
-                 goto fail;
+                 return AVERROR(ENOMEM);
              }
              memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
              codec->extradata_size= icodec->extradata_size;
 -            if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
 -                codec->time_base = icodec->time_base;
 -                codec->time_base.num *= icodec->ticks_per_frame;
 -                av_reduce(&codec->time_base.num, &codec->time_base.den,
 -                          codec->time_base.num, codec->time_base.den, INT_MAX);
 -            }else
 -                codec->time_base = ist->st->time_base;
 +
 +            codec->time_base = ist->st->time_base;
 +            if(!strcmp(os->oformat->name, "avi")) {
 +                if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
 +                    codec->time_base = icodec->time_base;
 +                    codec->time_base.num *= icodec->ticks_per_frame;
 +                    codec->time_base.den *= 2;
 +                }
 +            } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
 +                if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
 +                    codec->time_base = icodec->time_base;
 +                    codec->time_base.num *= icodec->ticks_per_frame;
 +                }
 +            }
 +            av_reduce(&codec->time_base.num, &codec->time_base.den,
 +                        codec->time_base.num, codec->time_base.den, INT_MAX);
 +
              switch(codec->codec_type) {
              case AVMEDIA_TYPE_AUDIO:
                  if(audio_volume != 256) {
              case AVMEDIA_TYPE_AUDIO:
                  ost->fifo= av_fifo_alloc(1024);
                  if (!ost->fifo) {
-                     ret = AVERROR(ENOMEM);
-                     goto fail;
+                     return AVERROR(ENOMEM);
                  }
                  ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
                  if (!codec->sample_rate) {
                      codec->sample_rate = icodec->sample_rate;
 -                    if (icodec->lowres)
 -                        codec->sample_rate >>= icodec->lowres;
                  }
                  choose_sample_rate(ost->st, ost->enc);
                  codec->time_base = (AVRational){1, codec->sample_rate};
                  if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
                      codec->sample_fmt = icodec->sample_fmt;
                  choose_sample_fmt(ost->st, ost->enc);
 -                if (!codec->channels)
 +                if (!codec->channels) {
                      codec->channels = icodec->channels;
 -                codec->channel_layout = icodec->channel_layout;
 +                    codec->channel_layout = icodec->channel_layout;
 +                }
                  if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
                      codec->channel_layout = 0;
                  ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
                                        codec->height  != icodec->height ||
                                        codec->pix_fmt != icodec->pix_fmt;
                  if (ost->video_resample) {
 -#if !CONFIG_AVFILTER
 -                    avcodec_get_frame_defaults(&ost->pict_tmp);
 -                    if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
 -                                       codec->width, codec->height)) {
 -                        fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
 -                        exit_program(1);
 -                    }
 -                    ost->img_resample_ctx = sws_getContext(
 -                        icodec->width,
 -                        icodec->height,
 -                        icodec->pix_fmt,
 -                        codec->width,
 -                        codec->height,
 -                        codec->pix_fmt,
 -                        ost->sws_flags, NULL, NULL, NULL);
 -                    if (ost->img_resample_ctx == NULL) {
 -                        fprintf(stderr, "Cannot get resampling context\n");
 -                        exit_program(1);
 -                    }
 -#endif
 -                    codec->bits_per_raw_sample= 0;
 +                    codec->bits_per_raw_sample= frame_bits_per_raw_sample;
                  }
  
                  ost->resample_height = icodec->height;
                      ost->frame_rate = ost->enc->supported_framerates[idx];
                  }
                  codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
 +                if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
 +                   && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
 +                    av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
 +                                               "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
 +                }
  
  #if CONFIG_AVFILTER
                  if (configure_video_filters(ist, ost)) {
                  break;
              }
              /* two pass mode */
 -            if (ost->encoding_needed &&
 +            if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
                  (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
                  char logfilename[1024];
                  FILE *f;
              }
          }
          if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
 +            /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
              int size= codec->width * codec->height;
 -            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
 +            bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
          }
      }
  
      if (!bit_buffer) {
          fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
                  bit_buffer_size);
-         ret = AVERROR(ENOMEM);
-         goto fail;
+         return AVERROR(ENOMEM);
      }
  
      /* open each encoder */
              ret = AVERROR(EINVAL);
              goto dump_format;
          }
 -        assert_avoptions(output_files[i].opts);
 +//        assert_avoptions(output_files[i].opts);
          if (strcmp(os->oformat->name, "rtp")) {
              want_sdp = 0;
          }
  
      if (ret) {
          fprintf(stderr, "%s\n", error);
-         goto fail;
+         return ret;
      }
  
      if (want_sdp) {
          print_sdp(output_files, nb_output_files);
      }
  
 -    if (verbose >= 0)
 -        fprintf(stderr, "Press ctrl-c to stop encoding\n");
+     return 0;
+ }
+ /*
+  * The following code is the main loop of the file converter
+  */
+ static int transcode(OutputFile *output_files,
+                      int nb_output_files,
+                      InputFile *input_files,
+                      int nb_input_files)
+ {
+     int ret, i;
+     AVFormatContext *is, *os;
+     OutputStream *ost;
+     InputStream *ist;
+     uint8_t *no_packet;
+     int no_packet_count=0;
+     int64_t timer_start;
++    int key;
+     if (!(no_packet = av_mallocz(nb_input_files)))
+         exit_program(1);
+     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
+     if (ret < 0)
+         goto fail;
 +    if (!using_stdin) {
 +        if(verbose >= 0)
 +            fprintf(stderr, "Press [q] to stop, [?] for help\n");
 +        avio_set_interrupt_cb(decode_interrupt_cb);
 +    }
      term_init();
  
      timer_start = av_gettime();
      redo:
          ipts_min = INT64_MAX;
          opts_min= 1e100;
 +        /* if 'q' pressed, exits */
 +        if (!using_stdin) {
 +            if (q_pressed)
 +                break;
 +            /* read_key() returns 0 on EOF */
 +            key = read_key();
 +            if (key == 'q')
 +                break;
 +            if (key == '+') verbose++;
 +            if (key == '-') verbose--;
 +            if (key == 's') qp_hist     ^= 1;
 +            if (key == 'h'){
 +                if (do_hex_dump){
 +                    do_hex_dump = do_pkt_dump = 0;
 +                } else if(do_pkt_dump){
 +                    do_hex_dump = 1;
 +                } else
 +                    do_pkt_dump = 1;
 +                av_log_set_level(AV_LOG_DEBUG);
 +            }
 +            if (key == 'd' || key == 'D'){
 +                int debug=0;
 +                if(key == 'D') {
 +                    debug = input_streams[0].st->codec->debug<<1;
 +                    if(!debug) debug = 1;
 +                    while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
 +                        debug += debug;
 +                }else
 +                    scanf("%d", &debug);
 +                for(i=0;i<nb_input_streams;i++) {
 +                    input_streams[i].st->codec->debug = debug;
 +                }
 +                for(i=0;i<nb_output_streams;i++) {
 +                    ost = &output_streams[i];
 +                    ost->st->codec->debug = debug;
 +                }
 +                if(debug) av_log_set_level(AV_LOG_DEBUG);
 +                fprintf(stderr,"debug=%d\n", debug);
 +            }
 +            if (key == '?'){
 +                fprintf(stderr, "key    function\n"
 +                                "?      show this help\n"
 +                                "+      increase verbosity\n"
 +                                "-      decrease verbosity\n"
 +                                "D      cycle through available debug modes\n"
 +                                "h      dump packets/hex press to cycle through the 3 states\n"
 +                                "q      quit\n"
 +                                "s      Show QP histogram\n"
 +                );
 +            }
 +        }
  
          /* select the stream that we must read now by looking at the
             smallest output pts */
          }
          /* the following test is needed in case new streams appear
             dynamically in stream : we ignore them */
 -        if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
 +        if (pkt.stream_index >= input_files[file_index].nb_streams)
              goto discard_packet;
          ist_index = input_files[file_index].ist_index + pkt.stream_index;
          ist = &input_streams[ist_index];
                  av_fifo_free(ost->fifo); /* works even if fifo is not
                                               initialized but set to zero */
                  av_freep(&ost->st->codec->subtitle_header);
 -                av_free(ost->pict_tmp.data[0]);
 +                av_free(ost->resample_frame.data[0]);
                  av_free(ost->forced_kf_pts);
                  if (ost->video_resample)
                      sws_freeContext(ost->img_resample_ctx);
@@@ -2605,7 -2509,7 +2617,7 @@@ static int opt_frame_pix_fmt(const cha
              return AVERROR(EINVAL);
          }
      } else {
 -        show_pix_fmts();
 +        opt_pix_fmts(NULL, NULL);
          exit_program(0);
      }
      return 0;
@@@ -2654,7 -2558,7 +2666,7 @@@ static int opt_metadata(const char *opt
  static int opt_qscale(const char *opt, const char *arg)
  {
      video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
 -    if (video_qscale == 0) {
 +    if (video_qscale <= 0 || video_qscale > 255) {
          fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
          return AVERROR(EINVAL);
      }
  static int opt_top_field_first(const char *opt, const char *arg)
  {
      top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
 -    return 0;
 +    return opt_default(opt, arg);
  }
  
  static int opt_thread_count(const char *opt, const char *arg)
@@@ -2994,18 -2898,16 +3006,18 @@@ static void add_input_streams(AVFormatC
  
          switch (dec->codec_type) {
          case AVMEDIA_TYPE_AUDIO:
 +            if(!ist->dec)
 +                ist->dec = avcodec_find_decoder(dec->codec_id);
              if(audio_disable)
                  st->discard= AVDISCARD_ALL;
              break;
          case AVMEDIA_TYPE_VIDEO:
 +            if(!ist->dec)
 +                ist->dec = avcodec_find_decoder(dec->codec_id);
              rfps      = ic->streams[i]->r_frame_rate.num;
              rfps_base = ic->streams[i]->r_frame_rate.den;
              if (dec->lowres) {
                  dec->flags |= CODEC_FLAG_EMU_EDGE;
 -                dec->height >>= dec->lowres;
 -                dec->width  >>= dec->lowres;
              }
              if(me_threshold)
                  dec->debug |= FF_DEBUG_MV;
          case AVMEDIA_TYPE_DATA:
              break;
          case AVMEDIA_TYPE_SUBTITLE:
 +            if(!ist->dec)
 +                ist->dec = avcodec_find_decoder(dec->codec_id);
              if(subtitle_disable)
                  st->discard = AVDISCARD_ALL;
              break;
@@@ -3168,9 -3068,7 +3180,9 @@@ static int opt_input_file(const char *o
      input_files[nb_input_files - 1].ctx        = ic;
      input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
      input_files[nb_input_files - 1].ts_offset  = input_ts_offset - (copy_ts ? 0 : timestamp);
 +    input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
  
 +    top_field_first = -1;
      frame_rate    = (AVRational){0, 0};
      frame_pix_fmt = PIX_FMT_NONE;
      frame_height = 0;
@@@ -3255,7 -3153,7 +3267,7 @@@ static OutputStream *new_video_stream(A
          ost->frame_aspect_ratio = frame_aspect_ratio;
          frame_aspect_ratio = 0;
  #if CONFIG_AVFILTER
 -        ost->avfilter= vfilters;
 +        ost->avfilter = vfilters;
          vfilters = NULL;
  #endif
      }
          video_enc->width = frame_width;
          video_enc->height = frame_height;
          video_enc->pix_fmt = frame_pix_fmt;
 +        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
          st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
  
          if (video_qscale || same_quant) {
@@@ -3475,7 -3372,7 +3487,7 @@@ static int opt_streamid(const char *opt
          exit_program(1);
      }
      *p++ = '\0';
 -    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
 +    idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
      streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
      streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
      return 0;
@@@ -3521,7 -3418,7 +3533,7 @@@ static int copy_chapters(int infile, in
      return 0;
  }
  
 -static int read_avserver_streams(AVFormatContext *s, const char *filename)
 +static int read_ffserver_streams(AVFormatContext *s, const char *filename)
  {
      int i, err;
      AVFormatContext *ic = NULL;
  
          // FIXME: a more elegant solution is needed
          memcpy(st, ic->streams[i], sizeof(AVStream));
 -        st->info = NULL;
 +        st->info = av_malloc(sizeof(*st->info));
 +        memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
          avcodec_copy_context(st->codec, ic->streams[i]->codec);
  
          if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
      return 0;
  }
  
 -static void opt_output_file(const char *filename)
 +static int opt_output_file(const char *opt, const char *filename)
  {
      AVFormatContext *oc;
      int i, err;
      if (!strcmp(filename, "-"))
          filename = "pipe:";
  
 -    oc = avformat_alloc_context();
 +    err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
 +    last_asked_format = NULL;
      if (!oc) {
 -        print_error(filename, AVERROR(ENOMEM));
 +        print_error(filename, err);
          exit_program(1);
      }
  
 -    if (last_asked_format) {
 -        file_oformat = av_guess_format(last_asked_format, NULL, NULL);
 -        if (!file_oformat) {
 -            fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
 -            exit_program(1);
 -        }
 -        last_asked_format = NULL;
 -    } else {
 -        file_oformat = av_guess_format(NULL, filename, NULL);
 -        if (!file_oformat) {
 -            fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
 -                    filename);
 -            exit_program(1);
 -        }
 -    }
 -
 -    oc->oformat = file_oformat;
 -    av_strlcpy(oc->filename, filename, sizeof(oc->filename));
 +    file_oformat= oc->oformat;
  
      if (!strcmp(file_oformat->name, "ffm") &&
          av_strstart(filename, "http:", NULL)) {
 -        /* special case for files sent to avserver: we get the stream
 -           parameters from avserver */
 -        int err = read_avserver_streams(oc, filename);
 +        /* special case for files sent to ffserver: we get the stream
 +           parameters from ffserver */
 +        int err = read_ffserver_streams(oc, filename);
          if (err < 0) {
              print_error(filename, err);
              exit_program(1);
  
      oc->preload= (int)(mux_preload*AV_TIME_BASE);
      oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
 -    oc->flags |= AVFMT_FLAG_NONBLOCK;
  
      /* copy chapters */
      if (chapters_input_file >= nb_input_files) {
      av_freep(&forced_key_frames);
      uninit_opts();
      init_opts();
 +    return 0;
  }
  
  /* same option as mencoder */
@@@ -3873,18 -3785,16 +3885,18 @@@ static void parse_matrix_coeffs(uint16_
      }
  }
  
 -static void opt_inter_matrix(const char *arg)
 +static int opt_inter_matrix(const char *opt, const char *arg)
  {
      inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
      parse_matrix_coeffs(inter_matrix, arg);
 +    return 0;
  }
  
 -static void opt_intra_matrix(const char *arg)
 +static int opt_intra_matrix(const char *opt, const char *arg)
  {
      intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
      parse_matrix_coeffs(intra_matrix, arg);
 +    return 0;
  }
  
  static void show_usage(void)
      printf("\n");
  }
  
 -static void show_help(void)
 +static int opt_help(const char *opt, const char *arg)
  {
      AVCodec *c;
      AVOutputFormat *oformat = NULL;
      }
  
      av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
 +    return 0;
  }
  
  static int opt_target(const char *opt, const char *arg)
  
          opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
          opt_frame_rate("r", frame_rates[norm]);
 +        opt_frame_pix_fmt("pix_fmt", "yuv420p");
          opt_default("g", norm == PAL ? "15" : "18");
  
          opt_default("b", "2040000");
  
          opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
          opt_frame_rate("r", frame_rates[norm]);
 +        opt_frame_pix_fmt("pix_fmt", "yuv420p");
          opt_default("g", norm == PAL ? "15" : "18");
  
          opt_default("b", "6000000");
@@@ -4147,20 -4054,6 +4159,20 @@@ static int opt_bsf(const char *opt, con
      return 0;
  }
  
 +static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
 +{
 +}
 +
 +static int opt_passlogfile(const char *opt, const char *arg)
 +{
 +    pass_logfilename_prefix = arg;
 +#if CONFIG_LIBX264_ENCODER
 +    return opt_default("passlogfile", arg);
 +#else
 +    return 0;
 +#endif
 +}
 +
  static const OptionDef options[] = {
      /* main options */
  #include "cmdutils_common_opts.h"
      { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
      { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
      { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
 -    { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
 +    { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
 +    { "croptop",  HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
      { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
        "use same quantizer as source (implies VBR)" },
      { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
 -    { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
 +    { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
      { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
        "deinterlace pictures" },
      { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
@@@ -4289,14 -4181,6 +4301,14 @@@ int main(int argc, char **argv
  
      av_log_set_flags(AV_LOG_SKIP_REPEATED);
  
 +    if(argc>1 && !strcmp(argv[1], "-d")){
 +        run_as_daemon=1;
 +        verbose=-1;
 +        av_log_set_callback(log_callback_null);
 +        argc--;
 +        argv++;
 +    }
 +
      avcodec_register_all();
  #if CONFIG_AVDEVICE
      avdevice_register_all();
  #endif
      av_register_all();
  
 -    avio_set_interrupt_cb(decode_interrupt_cb);
 +#if HAVE_ISATTY
 +    if(isatty(STDIN_FILENO))
 +        avio_set_interrupt_cb(decode_interrupt_cb);
 +#endif
  
      init_opts();
  
 -    show_banner();
 +    if(verbose>=0)
 +        show_banner();
  
      /* parse options */
      parse_options(argc, argv, options, opt_output_file);
diff --combined libavcodec/wavpack.c
@@@ -2,20 -2,20 +2,20 @@@
   * WavPack lossless audio decoder
   * Copyright (c) 2006,2011 Konstantin Shishkov
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  #define ALT_BITSTREAM_READER_LE
@@@ -1189,6 -1189,15 +1189,15 @@@ static int wavpack_decode_frame(AVCodec
      return s->samples_left > 0 ? 0 : avpkt->size;
  }
  
+ static void wavpack_decode_flush(AVCodecContext *avctx)
+ {
+     WavpackContext *s = avctx->priv_data;
+     int i;
+     for (i = 0; i < s->fdec_num; i++)
+         s->fdec[i]->samples_left = 0;
+ }
  AVCodec ff_wavpack_decoder = {
      .name           = "wavpack",
      .type           = AVMEDIA_TYPE_AUDIO,
      .init           = wavpack_decode_init,
      .close          = wavpack_decode_end,
      .decode         = wavpack_decode_frame,
+     .flush          = wavpack_decode_flush,
      .capabilities = CODEC_CAP_SUBFRAMES,
      .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
  };
diff --combined libavformat/wv.c
@@@ -2,20 -2,20 +2,20 @@@
   * WavPack demuxer
   * Copyright (c) 2006,2011 Konstantin Shishkov
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -250,14 -250,16 +250,16 @@@ static int wv_read_packet(AVFormatConte
      WVContext *wc = s->priv_data;
      int ret;
      int size, ver, off;
+     int64_t pos;
  
 -    if (s->pb->eof_reached)
 +    if (url_feof(s->pb))
          return AVERROR(EIO);
      if(wc->block_parsed){
          if(wv_read_block_header(s, s->pb, 0) < 0)
              return -1;
      }
  
+     pos = wc->pos;
      off = wc->multichannel ? 4 : 0;
      if(av_new_packet(pkt, wc->blksize + WV_EXTRA_SIZE + off) < 0)
          return AVERROR(ENOMEM);
      pkt->stream_index = 0;
      wc->block_parsed = 1;
      pkt->pts = wc->soff;
-     av_add_index_entry(s->streams[0], wc->pos, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
+     av_add_index_entry(s->streams[0], pos, pkt->pts, 0, 0, AVINDEX_KEYFRAME);
      return 0;
  }
  
@@@ -328,7 -330,8 +330,8 @@@ static int wv_read_seek(AVFormatContex
      int64_t pos, pts;
  
      /* if found, seek there */
-     if (index >= 0){
+     if (index >= 0 &&
+         timestamp <= st->index_entries[st->nb_index_entries - 1].timestamp) {
          wc->block_parsed = 1;
          avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET);
          return 0;