Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 1 Dec 2011 01:44:19 +0000 (02:44 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 1 Dec 2011 01:54:24 +0000 (02:54 +0100)
* qatar/master:
  rtpdec: Templatize the code for different g726 bitrate variants
  rv40: move loop filter to rv34dsp context
  lavf: make av_set_pts_info private.
  rtpdec: Add support for G726 audio
  rtpdec: Add an init function that can do custom codec context initialization
  avconv: make copy_tb on by default.
  matroskadec: don't set codec timebase.
  rmdec: don't set codec timebase.
  avconv: compute next_pts from input packet duration when possible.
  lavf: estimate frame duration from r_frame_rate.
  avconv: update InputStream.pts in the streamcopy case.

Conflicts:
avconv.c
libavdevice/alsa-audio-dec.c
libavdevice/bktr.c
libavdevice/fbdev.c
libavdevice/libdc1394.c
libavdevice/oss_audio.c
libavdevice/v4l.c
libavdevice/v4l2.c
libavdevice/vfwcap.c
libavdevice/x11grab.c
libavformat/au.c
libavformat/eacdata.c
libavformat/flvdec.c
libavformat/mpegts.c
libavformat/mxfenc.c
libavformat/rtpdec_g726.c
libavformat/wtv.c
libavformat/xmv.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
138 files changed:
1  2 
avconv.c
ffmpeg.c
libavcodec/rv40.c
libavcodec/rv40data.h
libavcodec/rv40dsp.c
libavdevice/alsa-audio-dec.c
libavdevice/bktr.c
libavdevice/fbdev.c
libavdevice/jack_audio.c
libavdevice/libcdio.c
libavdevice/libdc1394.c
libavdevice/oss_audio.c
libavdevice/pulse.c
libavdevice/sndio_dec.c
libavdevice/v4l.c
libavdevice/v4l2.c
libavdevice/vfwcap.c
libavdevice/x11grab.c
libavformat/4xm.c
libavformat/aacdec.c
libavformat/aiffdec.c
libavformat/aiffenc.c
libavformat/amr.c
libavformat/anm.c
libavformat/ape.c
libavformat/asfdec.c
libavformat/asfenc.c
libavformat/assdec.c
libavformat/au.c
libavformat/avformat.h
libavformat/avidec.c
libavformat/avienc.c
libavformat/avisynth.c
libavformat/bethsoftvid.c
libavformat/bfi.c
libavformat/bink.c
libavformat/c93.c
libavformat/cafdec.c
libavformat/cdg.c
libavformat/dfa.c
libavformat/dsicin.c
libavformat/dv.c
libavformat/dxa.c
libavformat/eacdata.c
libavformat/electronicarts.c
libavformat/ffmdec.c
libavformat/ffmenc.c
libavformat/filmstripdec.c
libavformat/flacdec.c
libavformat/flic.c
libavformat/flvdec.c
libavformat/flvenc.c
libavformat/gxf.c
libavformat/gxfenc.c
libavformat/idcin.c
libavformat/idroqdec.c
libavformat/iff.c
libavformat/img2.c
libavformat/internal.h
libavformat/ipmovie.c
libavformat/iss.c
libavformat/iv8.c
libavformat/ivfdec.c
libavformat/jvdec.c
libavformat/libnut.c
libavformat/lmlm4.c
libavformat/lxfdec.c
libavformat/matroskadec.c
libavformat/matroskaenc.c
libavformat/mm.c
libavformat/mmf.c
libavformat/mov.c
libavformat/movenc.c
libavformat/mp3dec.c
libavformat/mpc.c
libavformat/mpc8.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/nutenc.c
libavformat/nuv.c
libavformat/oggdec.c
libavformat/oggenc.c
libavformat/oggparsecelt.c
libavformat/oggparsedirac.c
libavformat/oggparseflac.c
libavformat/oggparseskeleton.c
libavformat/oma.c
libavformat/psxstr.c
libavformat/pva.c
libavformat/r3d.c
libavformat/rawdec.c
libavformat/rl2.c
libavformat/rmdec.c
libavformat/rpl.c
libavformat/rsodec.c
libavformat/rtpdec.h
libavformat/rtpdec_asf.c
libavformat/rtpdec_g726.c
libavformat/rtpdec_qt.c
libavformat/rtpenc.c
libavformat/rtsp.c
libavformat/segafilm.c
libavformat/sierravmd.c
libavformat/siff.c
libavformat/smacker.c
libavformat/sol.c
libavformat/soxdec.c
libavformat/srtdec.c
libavformat/swfdec.c
libavformat/thp.c
libavformat/tiertexseq.c
libavformat/tmv.c
libavformat/tta.c
libavformat/tty.c
libavformat/utils.c
libavformat/vc1test.c
libavformat/vc1testenc.c
libavformat/version.h
libavformat/vqf.c
libavformat/wav.c
libavformat/wc3movie.c
libavformat/westwood.c
libavformat/wv.c
libavformat/xa.c
libavformat/xmv.c
libavformat/xwma.c
libavformat/yop.c
libavformat/yuv4mpeg.c

diff --cc avconv.c
index adf12f79512d40e5646dd223d1cd52ecd082527b,d6045b7ef45e214f9155ebcd2c6021dd4256994f..9c94134943b2694a7e029dac0834a6c037cbf845
+++ b/avconv.c
@@@ -1822,8 -1745,11 +1822,10 @@@ static int transcode_video(InputStream 
          av_freep(&decoded_frame);
          return ret;
      }
 -    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
 -                                                 decoded_frame->pkt_dts);
 +    ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
-     if (ist->st->codec->time_base.num != 0) {
+     if (pkt->duration)
+         ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
+     else 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 *
@@@ -2132,25 -2066,14 +2135,15 @@@ static int transcode_init(OutputFile *o
                  return AVERROR(ENOMEM);
              }
              memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
-             codec->extradata_size= icodec->extradata_size;
-             codec->time_base = ist->st->time_base;
-             if(!strcmp(oc->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(!(oc->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);
++
+             codec->extradata_size = icodec->extradata_size;
+             if (!copy_tb) {
+                 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;
  
              switch(codec->codec_type) {
              case AVMEDIA_TYPE_AUDIO:
diff --cc ffmpeg.c
index f69d53fe1e790abf8e21d7e4a8795e1fd1f6bdb8,c731cec53b4b5d0f8ae0de84ba76fa5a64e3b613..b33506a09a4e71029cf9d455141ec53484f3c207
+++ b/ffmpeg.c
@@@ -1544,528 -1441,462 +1544,533 @@@ static void print_report(OutputFile *ou
      }
  }
  
 -static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
 +static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
  {
 -    int fill_char = 0x00;
 -    if (sample_fmt == AV_SAMPLE_FMT_U8)
 -        fill_char = 0x80;
 -    memset(buf, fill_char, size);
 -}
 +    int i, ret;
  
 -/* pkt = NULL means EOF (needed to flush decoder buffers) */
 -static int output_packet(InputStream *ist, int ist_index,
 -                         OutputStream **ost_table, int nb_ostreams,
 -                         const AVPacket *pkt)
 -{
 -    AVFormatContext *os;
 -    OutputStream *ost;
 -    int ret, i;
 -    int got_output;
 -    AVFrame picture;
 -    void *buffer_to_free = NULL;
 -    static unsigned int samples_size= 0;
 -    AVSubtitle subtitle, *subtitle_to_free;
 -    int64_t pkt_pts = AV_NOPTS_VALUE;
 -#if CONFIG_AVFILTER
 -    int frame_available;
 -#endif
 -    float quality;
 +    for (i = 0; i < nb_ostreams; i++) {
 +        OutputStream   *ost = &ost_table[i];
 +        AVCodecContext *enc = ost->st->codec;
 +        AVFormatContext *os = output_files[ost->file_index].ctx;
  
 -    AVPacket avpkt;
 -    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
 +        if (!ost->encoding_needed)
 +            continue;
  
 -    if(ist->next_pts == AV_NOPTS_VALUE)
 -        ist->next_pts= ist->pts;
 -
 -    if (pkt == NULL) {
 -        /* EOF handling */
 -        av_init_packet(&avpkt);
 -        avpkt.data = NULL;
 -        avpkt.size = 0;
 -        goto handle_eof;
 -    } else {
 -        avpkt = *pkt;
 -    }
 -
 -    if(pkt->dts != AV_NOPTS_VALUE)
 -        ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
 -    if(pkt->pts != AV_NOPTS_VALUE)
 -        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
 +        if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
 +            continue;
 +        if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
 +            continue;
  
 -    //while we have more to decode or while the decoder did output something on EOF
 -    while (avpkt.size > 0 || (!pkt && got_output)) {
 -        uint8_t *data_buf, *decoded_data_buf;
 -        int data_size, decoded_data_size;
 -    handle_eof:
 -        ist->pts= ist->next_pts;
 +        for(;;) {
 +            AVPacket pkt;
 +            int fifo_bytes;
 +            av_init_packet(&pkt);
 +            pkt.stream_index= ost->index;
  
 -        if(avpkt.size && avpkt.size != pkt->size &&
 -           ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
 -            fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
 -            ist->showed_multi_packet_warning=1;
 -        }
 +            switch (ost->st->codec->codec_type) {
 +            case AVMEDIA_TYPE_AUDIO:
 +                fifo_bytes = av_fifo_size(ost->fifo);
 +                ret = 0;
 +                /* encode any samples remaining in fifo */
 +                if (fifo_bytes > 0) {
 +                    int osize = av_get_bytes_per_sample(enc->sample_fmt);
 +                    int fs_tmp = enc->frame_size;
 +
 +                    av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
 +                    if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
 +                        enc->frame_size = fifo_bytes / (osize * enc->channels);
 +                    } else { /* pad */
 +                        int frame_bytes = enc->frame_size*osize*enc->channels;
 +                        if (allocated_audio_buf_size < frame_bytes)
 +                            exit_program(1);
 +                        generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
 +                    }
  
 -        /* decode the packet if needed */
 -        decoded_data_buf = NULL; /* fail safe */
 -        decoded_data_size= 0;
 -        data_buf  = avpkt.data;
 -        data_size = avpkt.size;
 -        subtitle_to_free = NULL;
 -        if (ist->decoding_needed) {
 -            switch(ist->st->codec->codec_type) {
 -            case AVMEDIA_TYPE_AUDIO:{
 -                if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
 -                    samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
 -                    av_free(samples);
 -                    samples= av_malloc(samples_size);
 +                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
 +                    pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
 +                                              ost->st->time_base.num, enc->sample_rate);
 +                    enc->frame_size = fs_tmp;
                  }
 -                decoded_data_size= samples_size;
 -                    /* XXX: could avoid copy if PCM 16 bits with same
 -                       endianness as CPU */
 -                ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
 -                                            &avpkt);
 -                if (ret < 0)
 -                    return ret;
 -                avpkt.data += ret;
 -                avpkt.size -= ret;
 -                data_size   = ret;
 -                got_output  = decoded_data_size > 0;
 -                /* Some bug in mpeg audio decoder gives */
 -                /* decoded_data_size < 0, it seems they are overflows */
 -                if (!got_output) {
 -                    /* no audio frame */
 -                    continue;
 +                if (ret <= 0) {
 +                    ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
                  }
 -                decoded_data_buf = (uint8_t *)samples;
 -                ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
 -                    (ist->st->codec->sample_rate * ist->st->codec->channels);
 -                break;}
 -            case AVMEDIA_TYPE_VIDEO:
 -                    decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
 -                    /* XXX: allocate picture correctly */
 -                    avcodec_get_frame_defaults(&picture);
 -                    avpkt.pts = pkt_pts;
 -                    avpkt.dts = ist->pts;
 -                    pkt_pts = AV_NOPTS_VALUE;
 -
 -                    ret = avcodec_decode_video2(ist->st->codec,
 -                                                &picture, &got_output, &avpkt);
 -                    quality = same_quality ? picture.quality : 0;
 -                    if (ret < 0)
 -                        return ret;
 -                    if (!got_output) {
 -                        /* no picture yet */
 -                        goto discard_packet;
 -                    }
 -                    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
 -                    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 *
 -                                          ist->st->codec->time_base.num * ticks) /
 -                            ist->st->codec->time_base.den;
 -                    }
 -                    avpkt.size = 0;
 -                    buffer_to_free = NULL;
 -                    pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
 -                    break;
 -            case AVMEDIA_TYPE_SUBTITLE:
 -                ret = avcodec_decode_subtitle2(ist->st->codec,
 -                                               &subtitle, &got_output, &avpkt);
 -                if (ret < 0)
 -                    return ret;
 -                if (!got_output) {
 -                    goto discard_packet;
 +                if (ret < 0) {
 +                    av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
 +                    exit_program(1);
                  }
 -                subtitle_to_free = &subtitle;
 -                avpkt.size = 0;
 -                break;
 -            default:
 -                return -1;
 -            }
 -        } else {
 -            switch(ist->st->codec->codec_type) {
 -            case AVMEDIA_TYPE_AUDIO:
 -                ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
 -                    ist->st->codec->sample_rate;
 +                audio_size += ret;
 +                pkt.flags |= AV_PKT_FLAG_KEY;
                  break;
              case AVMEDIA_TYPE_VIDEO:
 -                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 *
 -                                      ist->st->codec->time_base.num * ticks) /
 -                        ist->st->codec->time_base.den;
 +                ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
 +                if (ret < 0) {
 +                    av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
 +                    exit_program(1);
 +                }
 +                video_size += ret;
 +                if(enc->coded_frame && enc->coded_frame->key_frame)
 +                    pkt.flags |= AV_PKT_FLAG_KEY;
 +                if (ost->logfile && enc->stats_out) {
 +                    fprintf(ost->logfile, "%s", enc->stats_out);
                  }
                  break;
 +            default:
 +                ret=-1;
              }
 -            ret = avpkt.size;
 -            avpkt.size = 0;
 +
 +            if (ret <= 0)
 +                break;
 +            pkt.data = bit_buffer;
 +            pkt.size = ret;
 +            if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 +                pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 +            write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
          }
 +    }
 +}
  
 -#if CONFIG_AVFILTER
 -        if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 -            for (i = 0; i < nb_ostreams; i++) {
 -                ost = ost_table[i];
 -                if (ost->input_video_filter && ost->source_index == ist_index) {
 -                    AVRational sar;
 -                    if (ist->st->sample_aspect_ratio.num)
 -                        sar = ist->st->sample_aspect_ratio;
 -                    else
 -                        sar = ist->st->codec->sample_aspect_ratio;
 -                    // add it to be filtered
 -                    av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
 -                                             ist->pts,
 -                                             sar);
 -                }
 +/*
 + * Check whether a packet from ist should be written into ost at this time
 + */
 +static int check_output_constraints(InputStream *ist, OutputStream *ost)
 +{
 +    OutputFile *of = &output_files[ost->file_index];
 +    int ist_index  = ist - input_streams;
 +
 +    if (ost->source_index != ist_index)
 +        return 0;
 +
 +    if (of->start_time && ist->pts < of->start_time)
 +        return 0;
 +
 +    if (of->recording_time != INT64_MAX &&
 +        av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
 +                      (AVRational){1, 1000000}) >= 0) {
 +        ost->is_past_recording_time = 1;
 +        return 0;
 +    }
 +
 +    return 1;
 +}
 +
 +static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
 +{
 +    OutputFile *of = &output_files[ost->file_index];
 +    int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
 +    AVPicture pict;
 +    AVPacket opkt;
 +
 +    av_init_packet(&opkt);
 +
 +    if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
 +        !ost->copy_initial_nonkeyframes)
 +        return;
 +
 +    /* force the input stream PTS */
 +    if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 +        audio_size += pkt->size;
 +    else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 +        video_size += pkt->size;
 +        ost->sync_opts++;
 +    }
 +
 +    opkt.stream_index = ost->index;
 +    if (pkt->pts != AV_NOPTS_VALUE)
 +        opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
 +    else
 +        opkt.pts = AV_NOPTS_VALUE;
 +
 +    if (pkt->dts == AV_NOPTS_VALUE)
 +        opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
 +    else
 +        opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
 +    opkt.dts -= ost_tb_start_time;
 +
 +    opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
 +    opkt.flags    = pkt->flags;
 +
 +    //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
 +    if(   ost->st->codec->codec_id != CODEC_ID_H264
 +       && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
 +       && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
 +       ) {
 +        if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
 +            opkt.destruct = av_destruct_packet;
 +    } else {
 +        opkt.data = pkt->data;
 +        opkt.size = pkt->size;
 +    }
 +    if (of->ctx->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(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
 +    ost->st->codec->frame_number++;
 +    ost->frame_number++;
 +    av_free_packet(&opkt);
 +}
 +
 +static void rate_emu_sleep(InputStream *ist)
 +{
 +    if (input_files[ist->file_index].rate_emu) {
 +        int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
 +        int64_t now = av_gettime() - ist->start;
 +        if (pts > now)
 +            usleep(pts - now);
 +    }
 +}
 +
 +static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
 +{
 +    static unsigned int samples_size = 0;
 +    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
 +    uint8_t *decoded_data_buf  = NULL;
 +    int      decoded_data_size = 0;
 +    int i, ret;
 +
 +    if (pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
 +        av_free(samples);
 +        samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
 +        samples      = av_malloc(samples_size);
 +    }
 +    decoded_data_size = samples_size;
 +
 +    ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
 +                                pkt);
 +    if (ret < 0)
 +        return ret;
 +    *got_output  = decoded_data_size > 0;
 +
 +    /* Some bug in mpeg audio decoder gives */
 +    /* decoded_data_size < 0, it seems they are overflows */
 +    if (!*got_output) {
 +        /* no audio frame */
 +        return ret;
 +    }
 +
 +    decoded_data_buf = (uint8_t *)samples;
 +    ist->next_pts   += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
 +                       (ist->st->codec->sample_rate * ist->st->codec->channels);
 +
 +    // preprocess audio (volume)
 +    if (audio_volume != 256) {
 +        switch (ist->st->codec->sample_fmt) {
 +        case AV_SAMPLE_FMT_U8:
 +        {
 +            uint8_t *volp = samples;
 +            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
 +                int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
 +                *volp++ = av_clip_uint8(v);
              }
 +            break;
          }
 -#endif
 -
 -        // preprocess audio (volume)
 -        if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 -            if (audio_volume != 256) {
 -                short *volp;
 -                volp = samples;
 -                for(i=0;i<(decoded_data_size / sizeof(short));i++) {
 -                    int v = ((*volp) * audio_volume + 128) >> 8;
 -                    if (v < -32768) v = -32768;
 -                    if (v >  32767) v = 32767;
 -                    *volp++ = v;
 -                }
 +        case AV_SAMPLE_FMT_S16:
 +        {
 +            int16_t *volp = samples;
 +            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
 +                int v = ((*volp) * audio_volume + 128) >> 8;
 +                *volp++ = av_clip_int16(v);
              }
 +            break;
          }
 -
 -        /* frame rate emulation */
 -        if (rate_emu) {
 -            int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
 -            int64_t now = av_gettime() - ist->start;
 -            if (pts > now)
 -                usleep(pts - now);
 +        case AV_SAMPLE_FMT_S32:
 +        {
 +            int32_t *volp = samples;
 +            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
 +                int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
 +                *volp++ = av_clipl_int32(v);
 +            }
 +            break;
          }
 -        /* if output time reached then transcode raw format,
 -           encode packets and output them */
 -        if (start_time == 0 || ist->pts >= start_time)
 -            for(i=0;i<nb_ostreams;i++) {
 -                int frame_size;
 -
 -                ost = ost_table[i];
 -                if (ost->source_index == ist_index) {
 -#if CONFIG_AVFILTER
 -                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);
 -#endif
 -                    os = output_files[ost->file_index];
 -
 -                    /* set the input output pts pairs */
 -                    //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
 -
 -                    if (ost->encoding_needed) {
 -                        av_assert0(ist->decoding_needed);
 -                        switch(ost->st->codec->codec_type) {
 -                        case AVMEDIA_TYPE_AUDIO:
 -                            do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
 -                            break;
 -                        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;
 -#endif
 -                            do_video_out(os, ost, ist, &picture, &frame_size,
 -                                         same_quality ? quality : ost->st->codec->global_quality);
 -                            if (vstats_filename && frame_size)
 -                                do_video_stats(os, ost, frame_size);
 -                            break;
 -                        case AVMEDIA_TYPE_SUBTITLE:
 -                            do_subtitle_out(os, ost, ist, &subtitle,
 -                                            pkt->pts);
 -                            break;
 -                        default:
 -                            abort();
 -                        }
 -                    } else {
 -                        AVFrame avframe; //FIXME/XXX remove this
 -                        AVPacket opkt;
 -                        int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
 +        case AV_SAMPLE_FMT_FLT:
 +        {
 +            float *volp = samples;
 +            float scale = audio_volume / 256.f;
 +            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
 +                *volp++ *= scale;
 +            }
 +            break;
 +        }
 +        case AV_SAMPLE_FMT_DBL:
 +        {
 +            double *volp = samples;
 +            double scale = audio_volume / 256.;
 +            for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
 +                *volp++ *= scale;
 +            }
 +            break;
 +        }
 +        default:
 +            av_log(NULL, AV_LOG_FATAL,
 +                   "Audio volume adjustment on sample format %s is not supported.\n",
 +                   av_get_sample_fmt_name(ist->st->codec->sample_fmt));
 +            exit_program(1);
 +        }
 +    }
  
 -                        av_init_packet(&opkt);
 +    rate_emu_sleep(ist);
  
 -                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
 -#if !CONFIG_AVFILTER
 -                            continue;
 -#else
 -                            goto cont;
 +    for (i = 0; i < nb_output_streams; i++) {
 +        OutputStream *ost = &output_streams[i];
 +
 +        if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
 +            continue;
 +        do_audio_out(output_files[ost->file_index].ctx, ost, ist,
 +                     decoded_data_buf, decoded_data_size);
 +    }
 +    return ret;
 +}
 +
 +static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
 +{
 +    AVFrame *decoded_frame, *filtered_frame = NULL;
 +    void *buffer_to_free = NULL;
 +    int i, ret = 0;
 +    float quality = 0;
 +#if CONFIG_AVFILTER
 +    int frame_available = 1;
  #endif
  
 -                        /* no reencoding needed : output the packet directly */
 -                        /* force the input stream PTS */
 +    if (!(decoded_frame = avcodec_alloc_frame()))
 +        return AVERROR(ENOMEM);
 +    pkt->pts  = *pkt_pts;
 +    pkt->dts  = *pkt_dts;
 +    *pkt_pts  = AV_NOPTS_VALUE;
 +
-     if(*pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
++    if (*pkt_dts != AV_NOPTS_VALUE && pkt->duration) {
++         *pkt_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
++    } else if(*pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
 +        int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
 +        *pkt_dts += ((int64_t)AV_TIME_BASE *
 +                          ist->st->codec->time_base.num * ticks) /
 +            ist->st->codec->time_base.den;
 +    }else
 +        *pkt_dts = AV_NOPTS_VALUE;
  
 -                        avcodec_get_frame_defaults(&avframe);
 -                        ost->st->codec->coded_frame= &avframe;
 -                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
 +    ret = avcodec_decode_video2(ist->st->codec,
 +                                decoded_frame, got_output, pkt);
 +    if (ret < 0)
 +        goto fail;
  
 -                        if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 -                            audio_size += data_size;
 -                        else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 -                            video_size += data_size;
 -                            ost->sync_opts++;
 -                        }
 +    quality = same_quant ? decoded_frame->quality : 0;
 +    if (!*got_output) {
 +        /* no picture yet */
 +        av_freep(&decoded_frame);
 +        return ret;
 +    }
  
 -                        opkt.stream_index= ost->index;
 -                        if(pkt->pts != AV_NOPTS_VALUE)
 -                            opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
 -                        else
 -                            opkt.pts= AV_NOPTS_VALUE;
 -
 -                        if (pkt->dts == AV_NOPTS_VALUE)
 -                            opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
 -                        else
 -                            opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
 -                        opkt.dts -= ost_tb_start_time;
 -
 -                        opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
 -                        opkt.flags= pkt->flags;
 -
 -                        //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
 -                        if(   ost->st->codec->codec_id != CODEC_ID_H264
 -                           && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
 -                           && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
 -                           ) {
 -                            if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
 -                                opkt.destruct= av_destruct_packet;
 -                        } else {
 -                            opkt.data = data_buf;
 -                            opkt.size = data_size;
 -                        }
 +    if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
 +        ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
 +
-     if (ist->st->codec->time_base.num != 0) {
++    if (pkt->duration)
++        ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
++    else 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 *
 +                          ist->st->codec->time_base.num * ticks) /
 +                          ist->st->codec->time_base.den;
 +    }
 +    pkt->size = 0;
  
 -                        write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
 -                        ost->st->codec->frame_number++;
 -                        ost->frame_number++;
 -                        av_free_packet(&opkt);
 -                    }
 -#if CONFIG_AVFILTER
 -                    cont:
 -                    frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
 -                                       ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
 -                    if (ost->picref)
 -                        avfilter_unref_buffer(ost->picref);
 -                }
 -#endif
 -                }
 -            }
 +    pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
  
 -        av_free(buffer_to_free);
 -        /* XXX: allocate the subtitles in the codec ? */
 -        if (subtitle_to_free) {
 -            avsubtitle_free(subtitle_to_free);
 -            subtitle_to_free = NULL;
 +#if CONFIG_AVFILTER
 +    for(i=0;i<nb_output_streams;i++) {
 +        OutputStream *ost = ost = &output_streams[i];
 +        if(check_output_constraints(ist, ost)){
 +            if (!decoded_frame->sample_aspect_ratio.num)
 +                decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
 +            decoded_frame->pts = ist->pts;
 +
 +            av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
          }
      }
 - discard_packet:
 -    if (pkt == NULL) {
 -        /* EOF handling */
 +#endif
  
 -        for(i=0;i<nb_ostreams;i++) {
 -            ost = ost_table[i];
 -            if (ost->source_index == ist_index) {
 -                AVCodecContext *enc= ost->st->codec;
 -                os = output_files[ost->file_index];
 -
 -                if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
 -                    continue;
 -                if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
 -                    continue;
 -
 -                if (ost->encoding_needed) {
 -                    for(;;) {
 -                        AVPacket pkt;
 -                        int fifo_bytes;
 -                        av_init_packet(&pkt);
 -                        pkt.stream_index= ost->index;
 -
 -                        switch(ost->st->codec->codec_type) {
 -                        case AVMEDIA_TYPE_AUDIO:
 -                            fifo_bytes = av_fifo_size(ost->fifo);
 -                            ret = 0;
 -                            /* encode any samples remaining in fifo */
 -                            if (fifo_bytes > 0) {
 -                                int osize = av_get_bytes_per_sample(enc->sample_fmt);
 -                                int fs_tmp = enc->frame_size;
 -
 -                                av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
 -                                if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
 -                                    enc->frame_size = fifo_bytes / (osize * enc->channels);
 -                                } else { /* pad */
 -                                    int frame_bytes = enc->frame_size*osize*enc->channels;
 -                                    if (allocated_audio_buf_size < frame_bytes)
 -                                        exit_program(1);
 -                                    generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
 -                                }
 -
 -                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
 -                                pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
 -                                                          ost->st->time_base.num, enc->sample_rate);
 -                                enc->frame_size = fs_tmp;
 -                            }
 -                            if(ret <= 0) {
 -                                ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
 -                            }
 -                            if (ret < 0) {
 -                                fprintf(stderr, "Audio encoding failed\n");
 -                                exit_program(1);
 -                            }
 -                            audio_size += ret;
 -                            pkt.flags |= AV_PKT_FLAG_KEY;
 -                            break;
 -                        case AVMEDIA_TYPE_VIDEO:
 -                            ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
 -                            if (ret < 0) {
 -                                fprintf(stderr, "Video encoding failed\n");
 -                                exit_program(1);
 -                            }
 -                            video_size += ret;
 -                            if(enc->coded_frame && enc->coded_frame->key_frame)
 -                                pkt.flags |= AV_PKT_FLAG_KEY;
 -                            if (ost->logfile && enc->stats_out) {
 -                                fprintf(ost->logfile, "%s", enc->stats_out);
 -                            }
 -                            break;
 -                        default:
 -                            ret=-1;
 -                        }
 +    rate_emu_sleep(ist);
  
 -                        if(ret<=0)
 -                            break;
 -                        pkt.data= bit_buffer;
 -                        pkt.size= ret;
 -                        if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 -                            pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 -                        write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
 -                    }
 +    for (i = 0; i < nb_output_streams; i++) {
 +        OutputStream *ost = &output_streams[i];
 +        int frame_size;
 +
 +        if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
 +            continue;
 +
 +#if CONFIG_AVFILTER
 +        if (ost->input_video_filter) {
 +            frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
 +        }
 +        while (frame_available) {
 +            if (ost->output_video_filter) {
 +                AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
 +                if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
 +                    goto cont;
 +                if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
 +                    ret = AVERROR(ENOMEM);
 +                    goto fail;
 +                }
 +                *filtered_frame= *decoded_frame; //for me_threshold
 +                if (ost->picref) {
 +                    avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
 +                    ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
                  }
              }
 +            if (ost->picref->video && !ost->frame_aspect_ratio)
 +                ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
 +#else
 +            filtered_frame = decoded_frame;
 +#endif
 +
 +            do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
 +                         same_quant ? quality : ost->st->codec->global_quality);
 +            if (vstats_filename && frame_size)
 +                do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
 +#if CONFIG_AVFILTER
 +            cont:
 +            frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
 +            avfilter_unref_buffer(ost->picref);
          }
 +        av_freep(&filtered_frame);
 +#endif
      }
  
 -    return 0;
 +fail:
 +    av_free(buffer_to_free);
 +    av_freep(&decoded_frame);
 +    return ret;
  }
  
 -static void print_sdp(AVFormatContext **avc, int n)
 +static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
  {
 -    char sdp[2048];
 +    AVSubtitle subtitle;
 +    int i, ret = avcodec_decode_subtitle2(ist->st->codec,
 +                                          &subtitle, got_output, pkt);
 +    if (ret < 0)
 +        return ret;
 +    if (!*got_output)
 +        return ret;
  
 -    av_sdp_create(avc, n, sdp, sizeof(sdp));
 -    printf("SDP:\n%s\n", sdp);
 -    fflush(stdout);
 +    rate_emu_sleep(ist);
 +
 +    for (i = 0; i < nb_output_streams; i++) {
 +        OutputStream *ost = &output_streams[i];
 +
 +        if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
 +            continue;
 +
 +        do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
 +    }
 +
 +    avsubtitle_free(&subtitle);
 +    return ret;
  }
  
 -static int copy_chapters(int infile, int outfile)
 +/* pkt = NULL means EOF (needed to flush decoder buffers) */
 +static int output_packet(InputStream *ist,
 +                         OutputStream *ost_table, int nb_ostreams,
 +                         const AVPacket *pkt)
  {
 -    AVFormatContext *is = input_files[infile].ctx;
 -    AVFormatContext *os = output_files[outfile];
 -    int i;
 +    int ret = 0, i;
 +    int got_output;
 +    int64_t pkt_dts = AV_NOPTS_VALUE;
 +    int64_t pkt_pts = AV_NOPTS_VALUE;
  
 -    for (i = 0; i < is->nb_chapters; i++) {
 -        AVChapter *in_ch = is->chapters[i], *out_ch;
 -        int64_t ts_off   = av_rescale_q(start_time - input_files[infile].ts_offset,
 -                                      AV_TIME_BASE_Q, in_ch->time_base);
 -        int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
 -                           av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
 +    AVPacket avpkt;
  
 +    if (ist->next_pts == AV_NOPTS_VALUE)
 +        ist->next_pts = ist->pts;
  
 -        if (in_ch->end < ts_off)
 -            continue;
 -        if (rt != INT64_MAX && in_ch->start > rt + ts_off)
 +    if (pkt == NULL) {
 +        /* EOF handling */
 +        av_init_packet(&avpkt);
 +        avpkt.data = NULL;
 +        avpkt.size = 0;
 +        goto handle_eof;
 +    } else {
 +        avpkt = *pkt;
 +    }
 +
 +    if(pkt->dts != AV_NOPTS_VALUE){
 +        if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
 +            ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
 +        pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
 +    }
 +    if(pkt->pts != AV_NOPTS_VALUE)
 +        pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
 +
 +    //while we have more to decode or while the decoder did output something on EOF
 +    while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
 +    handle_eof:
 +
 +        ist->pts = ist->next_pts;
 +
 +        if (avpkt.size && avpkt.size != pkt->size) {
 +            av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
 +                   "Multiple frames in a packet from stream %d\n", pkt->stream_index);
 +            ist->showed_multi_packet_warning = 1;
 +        }
 +
 +        switch(ist->st->codec->codec_type) {
 +        case AVMEDIA_TYPE_AUDIO:
 +            ret = transcode_audio    (ist, &avpkt, &got_output);
 +            break;
 +        case AVMEDIA_TYPE_VIDEO:
 +            ret = transcode_video    (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
 +            break;
 +        case AVMEDIA_TYPE_SUBTITLE:
 +            ret = transcode_subtitles(ist, &avpkt, &got_output);
              break;
 +        default:
 +            return -1;
 +        }
  
 -        out_ch = av_mallocz(sizeof(AVChapter));
 -        if (!out_ch)
 -            return AVERROR(ENOMEM);
 +        if (ret < 0)
 +            return ret;
 +        // touch data and size only if not EOF
 +        if (pkt) {
 +            if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
 +                ret = avpkt.size;
 +            avpkt.data += ret;
 +            avpkt.size -= ret;
 +        }
 +        if (!got_output) {
 +            continue;
 +        }
 +    }
  
 -        out_ch->id        = in_ch->id;
 -        out_ch->time_base = in_ch->time_base;
 -        out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
 -        out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
 +    /* handle stream copy */
 +    if (!ist->decoding_needed) {
 +        rate_emu_sleep(ist);
++        ist->pts = ist->next_pts;
 +        switch (ist->st->codec->codec_type) {
 +        case AVMEDIA_TYPE_AUDIO:
 +            ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
 +                             ist->st->codec->sample_rate;
 +            break;
 +        case AVMEDIA_TYPE_VIDEO:
 +            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 *
 +                                  ist->st->codec->time_base.num * ticks) /
 +                                  ist->st->codec->time_base.den;
 +            }
 +            break;
 +        }
 +    }
 +    for (i = 0; pkt && i < nb_ostreams; i++) {
 +        OutputStream *ost = &ost_table[i];
  
 -        if (metadata_chapters_autocopy)
 -            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
 +        if (!check_output_constraints(ist, ost) || ost->encoding_needed)
 +            continue;
  
 -        os->nb_chapters++;
 -        os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
 -        if (!os->chapters)
 -            return AVERROR(ENOMEM);
 -        os->chapters[os->nb_chapters - 1] = out_ch;
 +        do_streamcopy(ist, ost, pkt);
      }
 +
      return 0;
  }
  
Simple merge
Simple merge
Simple merge
index bd00b1535b93601e26cc07408308598d0d591313,5344b1988dbc252247f391688e1fb409ee32f0a2..bb9d233a4e95625bc8c5b1b827cf0b63cb844d60
   */
  
  #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,
      st->codec->codec_id    = codec_id;
      st->codec->sample_rate = s->sample_rate;
      st->codec->channels    = s->channels;
-     av_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
+     avpriv_set_pts_info(st, 64, 1, 1000000);  /* 64 bits pts in us */
 +    o = 2 * M_PI * s->period_size / s->sample_rate * 1.5; // bandwidth: 1.5Hz
 +    s->timefilter = ff_timefilter_new(1000000.0 / s->sample_rate,
 +                                      sqrt(2 * o), o * o);
 +    if (!s->timefilter)
 +        goto fail;
  
      return 0;
  
index 72f0cc272e0ea749de8e9b65e35784f0c513ec55,e6a1e8ba2df07b336fbaf792ccbaa60d412dbba7..6e3970128fc0f78a8561a85d0e64c88b78f972b2
@@@ -24,6 -24,8 +24,7 @@@
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "libavutil/parseutils.h"
index fdd946d598b1fdcc226d07b7e67de633d177bfa0,7444f47e570dadea69e4e2fbdd609d32db47ad53..ee5ecee89dfbb72a15d865dfe000f8cd5de2991a
@@@ -42,7 -42,8 +42,8 @@@
  #include "libavutil/opt.h"
  #include "libavutil/parseutils.h"
  #include "libavutil/pixdesc.h"
 -#include "libavformat/avformat.h"
 +#include "avdevice.h"
+ #include "libavformat/internal.h"
  
  struct rgb_pixfmt_map_entry {
      int bits_per_pixel;
index 42499d363b05f36ae6ea07e01319e5e8fd733075,dbe1771ebfeb1c794c721787632904cc954495a5..b1077c4ebedd3a3860ff2a1baf78dca63229f560
@@@ -29,8 -29,8 +29,9 @@@
  #include "libavutil/opt.h"
  #include "libavcodec/avcodec.h"
  #include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "timefilter.h"
 +#include "avdevice.h"
  
  /**
   * Size of the internal FIFO buffers as a number of audio packets
Simple merge
index 2f3a373114db07c6a4ea1f73024aa6f3f4ba505c,71f08b137d2e403e447b3192f96e1459bf0b24e4..754f8bf8c1f47a2eb4dc2f904fbe4ae9d1d523c5
@@@ -22,6 -21,8 +22,7 @@@
   */
  
  #include "config.h"
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "libavutil/log.h"
  #include "libavutil/mathematics.h"
  #include "libavutil/opt.h"
@@@ -254,16 -162,18 +255,16 @@@ static int dc1394_read_header(AVFormatC
  
      /* create a video stream */
      vst = avformat_new_stream(c, NULL);
 -    if (!vst) {
 -        ret = AVERROR(ENOMEM);
 -        goto out;
 -    }
 +    if (!vst)
 +        goto out_camera;
-     av_set_pts_info(vst, 64, 1, 1000);
+     avpriv_set_pts_info(vst, 64, 1, 1000);
      vst->codec->codec_type = AVMEDIA_TYPE_VIDEO;
      vst->codec->codec_id = CODEC_ID_RAWVIDEO;
 -    vst->codec->time_base.den = framerate.num;
 -    vst->codec->time_base.num = framerate.den;
 -    vst->codec->width = fmt->width;
 -    vst->codec->height = fmt->height;
 -    vst->codec->pix_fmt = fmt->pix_fmt;
 +    vst->codec->time_base.den = final_frame_rate;
 +    vst->codec->time_base.num = 1000;
 +    vst->codec->width = final_width;
 +    vst->codec->height = final_height;
 +    vst->codec->pix_fmt = final_pix_fmt;
  
      /* packet init */
      av_init_packet(&dc1394->packet);
index 4432376037a9cf33899a92f4dea2458d2089ce6d,308fc0df970b94982f76be5c5144be874f53c54f..e3ab9267044279132add1a667396618de2792eaf
@@@ -39,7 -39,8 +39,8 @@@
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "libavcodec/avcodec.h"
 -#include "libavformat/avformat.h"
 +#include "avdevice.h"
+ #include "libavformat/internal.h"
  
  #define AUDIO_BLOCK_SIZE 4096
  
Simple merge
Simple merge
index bbb58fbded704fad793db099fc94ea1bfcfdd914,bdfee2df4e25d5041c3a657103fcf09edba00641..4b0e7198d6ff159c96c34b863970cbce203b81ac
@@@ -29,6 -29,8 +29,7 @@@
  #include "libavutil/imgutils.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "libavcodec/dsputil.h"
  #include <unistd.h>
  #include <fcntl.h>
index 07d3cb445db213a5529055e17c1be13922a662f2,0c61f46b53b998b8944943a7cc6fbef4e6059b18..dc54c4a2059a4414a24eaa351b50a292e9c6dd0f
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +/**
 + * @file
 + * Video4Linux2 grab interface
 + *
 + * Part of this file is based on the V4L2 video capture example
 + * (http://v4l2spec.bytesex.org/v4l2spec/capture.c)
 + *
 + * Thanks to Michael Niedermayer for providing the mapping between
 + * V4L2_PIX_FMT_* and PIX_FMT_*
 + */
 +
  #undef __STRICT_ANSI__ //workaround due to broken kernel headers
  #include "config.h"
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include <unistd.h>
  #include <fcntl.h>
  #include <sys/ioctl.h>
index 09330dea4657abd8d422dc8b8d32213f422d34a7,b5baee3b793525b039726f8ac8db9127fde35cc0..9a525ea27ad20336ff8510f33ba9d1f912623172
@@@ -19,6 -19,8 +19,7 @@@
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "libavutil/parseutils.h"
@@@ -397,9 -397,7 +398,9 @@@ static int vfw_read_header(AVFormatCont
          }
      }
  
-     av_set_pts_info(st, 32, 1, 1000);
 +    av_freep(&bi);
 +
+     avpriv_set_pts_info(st, 32, 1, 1000);
  
      ctx->mutex = CreateMutex(NULL, 0, NULL);
      if(!ctx->mutex) {
index 2ecf88c2d5c08badd6581f88c46d53dd02b74a97,5673e5e611c113da5d8a964fbc5679a49b794801..15036b849ef4bc451b87084bce401a0e8192612e
@@@ -36,6 -36,8 +36,7 @@@
   */
  
  #include "config.h"
 -#include "libavformat/avformat.h"
+ #include "libavformat/internal.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "libavutil/parseutils.h"
Simple merge
Simple merge
index eee9a1c483f04b36255f0e89051d8d6f4fb55255,f54a7ffafe5b21d19c53644d8981bb9ca0e6ddde..66f8eefc759c71a068c6a6eedfb081ad18d0ab7c
  #include "libavutil/intfloat_readwrite.h"
  #include "libavutil/dict.h"
  #include "avformat.h"
+ #include "internal.h"
  #include "pcm.h"
  #include "aiff.h"
 +#include "isom.h"
  
  #define AIFF                    0
  #define AIFF_C_VERSION1         0xA2805140
index 3b2fc381605f14444ed6a15b4bdc70f637b049b3,df43688d401953ec307cf400889c0d128d842161..9a4f41b3f3942ddcc31ae42afbcc2c2900362425
  
  #include "libavutil/intfloat_readwrite.h"
  #include "avformat.h"
+ #include "internal.h"
  #include "aiff.h"
  #include "avio_internal.h"
 +#include "isom.h"
  
  typedef struct {
      int64_t form;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 610880d842782497d10debd5114c17359e6dfde2,c6fb8dbaa95d359ec558e6b698a59caea62d09f7..3dfb3be00421768ac95f860c1b4ae45d9d035b0d
@@@ -164,9 -160,7 +165,9 @@@ static int au_read_header(AVFormatConte
      st->codec->codec_id = codec;
      st->codec->channels = channels;
      st->codec->sample_rate = rate;
-     av_set_pts_info(st, 64, 1, rate);
 +    if (data_size != AU_UNKNOWN_SIZE)
 +    st->duration = (((int64_t)data_size)<<3) / (st->codec->channels * bps);
+     avpriv_set_pts_info(st, 64, 1, rate);
      return 0;
  }
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index adf48c6a19b429b92d3f2500d69f00e0ccacd626,8fe144e6a9b325465ee239e628b218aa9b6803d4..2311f0bcd17dcad669155b2f5aa1e33e34201539
@@@ -73,10 -72,8 +74,10 @@@ static int cdata_read_header(AVFormatCo
      st->codec->codec_tag = 0; /* no fourcc */
      st->codec->codec_id = CODEC_ID_ADPCM_EA_XAS;
      st->codec->channels = cdata->channels;
 +    st->codec->channel_layout = channel_layout;
      st->codec->sample_rate = sample_rate;
-     av_set_pts_info(st, 64, 1, sample_rate);
 +    st->codec->sample_fmt = AV_SAMPLE_FMT_S16;
+     avpriv_set_pts_info(st, 64, 1, sample_rate);
  
      cdata->audio_pts = 0;
      return 0;
Simple merge
index b8cf119cb3d6e1ea5194d0451e0b1b590ce170f0,114576707e4e2dd5ba497bcd15cf50656bbb9c65..86e31cc0af1f50ed35947443a8af384d1e912068
@@@ -22,8 -22,9 +22,9 @@@
  #include "libavutil/intreadwrite.h"
  #include "libavutil/intfloat_readwrite.h"
  #include "avformat.h"
+ #include "internal.h"
  #include "ffm.h"
 -#if CONFIG_AVSERVER
 +#if CONFIG_FFSERVER
  #include <unistd.h>
  
  int64_t ffm_read_write_index(int fd)
Simple merge
Simple merge
Simple merge
Simple merge
index 1095f95b7b69033afbcf99dc72b3bff2f9c0194d,5d19dd84130edb7ac7e4558051893848f8b89b04..4bca6a6580930c8257cc4523a4540b8dc721d4da
@@@ -356,16 -359,9 +357,16 @@@ static AVStream *create_stream(AVFormat
      AVStream *st = avformat_new_stream(s, NULL);
      if (!st)
          return NULL;
 -    st->id = is_audio;
 -    st->codec->codec_type = is_audio ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
 +    st->id = stream_type;
 +    switch(stream_type) {
 +        case FLV_STREAM_TYPE_VIDEO:    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;    break;
 +        case FLV_STREAM_TYPE_AUDIO:    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;    break;
 +        case FLV_STREAM_TYPE_DATA:
 +            st->codec->codec_type = AVMEDIA_TYPE_DATA;
 +            st->codec->codec_id = CODEC_ID_NONE; // Going to rely on copy for now
 +            av_log(s, AV_LOG_DEBUG, "Data stream created\n");
 +    }
-     av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
+     avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
      return st;
  }
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index a816af580b2ee6d89c987ca58f4b7be16d5e5e94,b895cf2e678861d0db541a847a533717dd11ec7b..ebc1c35ba5dd9f01a42bb4b1cac644fec7f7dd58
@@@ -238,9 -217,9 +239,9 @@@ static int iff_read_header(AVFormatCont
  
      switch(st->codec->codec_type) {
      case AVMEDIA_TYPE_AUDIO:
-         av_set_pts_info(st, 32, 1, st->codec->sample_rate);
+         avpriv_set_pts_info(st, 32, 1, st->codec->sample_rate);
  
 -        switch(compression) {
 +        switch (iff->svx8_compression) {
          case COMP_NONE:
              st->codec->codec_id = CODEC_ID_PCM_S8_PLANAR;
              break;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index bea5c050b877ccc37df7a29d98252f1cf3467026,a741c4b7d06302db49524e4a69787a78ca930dc6..8aac2a32e009855befdbc2489f09b76e4ecd978d
@@@ -2297,14 -2258,9 +2297,14 @@@ static int mov_write_header(AVFormatCon
          if (!track->height)
              track->height = st->codec->height;
  
-         av_set_pts_info(st, 64, 1, track->timescale);
+         avpriv_set_pts_info(st, 64, 1, track->timescale);
      }
  
 +    if(mov->reserved_moov_size){
 +        mov->reserved_moov_pos= avio_tell(pb);
 +        avio_skip(pb, mov->reserved_moov_size);
 +    }
 +
      mov_write_mdat_tag(pb, mov);
  
  #if FF_API_TIMESTAMP
Simple merge
Simple merge
Simple merge
Simple merge
index d3f8a8a783846238f10f7fe5e5cf28b6ad1c4981,f7045cee5e20afeaf866482c7320e20c7456d7a8..8d026fd3724d920cad296a9a537adab05851203e
@@@ -600,9 -577,7 +600,9 @@@ static void mpegts_find_stream_type(AVS
  static int mpegts_set_stream_info(AVStream *st, PESContext *pes,
                                    uint32_t stream_type, uint32_t prog_reg_desc)
  {
-     av_set_pts_info(st, 33, 1, 90000);
 +    int old_codec_type= st->codec->codec_type;
 +    int old_codec_id  = st->codec->codec_id;
+     avpriv_set_pts_info(st, 33, 1, 90000);
      st->priv_data = pes;
      st->codec->codec_type = AVMEDIA_TYPE_DATA;
      st->codec->codec_id   = CODEC_ID_NONE;
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index ce71ed2e51aa47edf91d3bc84c2d6ed292ec0f0d,a7eb4327594f48abbf306dfdd3c0d4cfab5eb4cc..0b62a5a851c54aeb5df054b2d76fe2c300526937
@@@ -1428,13 -1438,7 +1428,13 @@@ static int mxf_write_header(AVFormatCon
                  av_log(s, AV_LOG_ERROR, "unsupported video frame rate\n");
                  return -1;
              }
-             av_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
+             avpriv_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
 +            if (mxf->tc.str) {
 +                mxf->tc.rate.num = mxf->time_base.den;
 +                mxf->tc.rate.den = mxf->time_base.num;
 +                if (ff_init_smtpe_timecode(s, &mxf->tc) < 0)
 +                    return -1;
 +            }
              if (s->oformat == &ff_mxf_d10_muxer) {
                  if (st->codec->bit_rate == 50000000)
                      if (mxf->time_base.den == 25) sc->index = 3;
Simple merge
Simple merge
index 5de7512f997f1b7810046d06470772f70d6d5ca4,18dfde2867ee42f140192039b029d63fcaffab78..6e1d268e6850a65772842b2eef59201f6ada6d5b
  
  #include "libavutil/mathematics.h"
  #include "avformat.h"
+ #include "internal.h"
  #include "riff.h"
  #include "libavutil/dict.h"
 +#include "libavutil/intreadwrite.h"
  
  //#define DEBUG_DUMP_INDEX // XXX dumbdriving-271.nsv breaks with it commented!!
  #define CHECK_SUBSEQUENT_NSVS
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 982d3d7ea5db93e5304e57a316ba08ce6ae1eb59,5f07de40cb15dd935edfeb6595fee9f898c174f8..fc5891b0919a2e331c87e29a4759be4a589be429
@@@ -70,9 -72,8 +71,9 @@@ static int celt_header(AVFormatContext 
          st->codec->extradata      = extradata;
          st->codec->extradata_size = 2 * sizeof(uint32_t);
          if (sample_rate)
-             av_set_pts_info(st, 64, 1, sample_rate);
+             avpriv_set_pts_info(st, 64, 1, sample_rate);
          priv->extra_headers_left  = 1 + extra_headers;
 +        av_free(os->private);
          os->private = priv;
          AV_WL32(extradata + 0, overlap);
          AV_WL32(extradata + 4, version);
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 13d7928818ae1bd0cd59316a09457bb5f4a1bbd2,10e79eb4da7cd03bee949ce943329425376f38d7..0ac6860444a08a62239c05221a7313daf457f669
@@@ -869,7 -826,10 +869,10 @@@ static void compute_frame_duration(int 
      *pden = 0;
      switch(st->codec->codec_type) {
      case AVMEDIA_TYPE_VIDEO:
-         if(st->time_base.num*1000LL > st->time_base.den){
 -        if (st->r_frame_rate.num) {
++        if (st->r_frame_rate.num && !pc) {
+             *pnum = st->r_frame_rate.den;
+             *pden = st->r_frame_rate.num;
+         } else if(st->time_base.num*1000LL > st->time_base.den) {
              *pnum = st->time_base.num;
              *pden = st->time_base.den;
          }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index aeafcb690430a8fbbf0d07b6cb75987eccc8a013,bc4b23917a7d5df269cd3dd35802d7a8b11a626c..f01e0aa77b38abb957773d66a43426691ec9f9b6
  #include "libavutil/intreadwrite.h"
  
  #include "avformat.h"
+ #include "internal.h"
  #include "riff.h"
  
 +/** The min size of an XMV header. */
  #define XMV_MIN_HEADER_SIZE 36
  
 +/** Audio flag: ADPCM'd 5.1 stream, front left / right channels */
  #define XMV_AUDIO_ADPCM51_FRONTLEFTRIGHT 1
 +/** Audio flag: ADPCM'd 5.1 stream, front center / low frequency channels */
  #define XMV_AUDIO_ADPCM51_FRONTCENTERLOW 2
 +/** Audio flag: ADPCM'd 5.1 stream, rear left / right channels */
  #define XMV_AUDIO_ADPCM51_REARLEFTRIGHT  4
  
 +/** Audio flag: Any of the ADPCM'd 5.1 stream flags. */
  #define XMV_AUDIO_ADPCM51 (XMV_AUDIO_ADPCM51_FRONTLEFTRIGHT | \
                             XMV_AUDIO_ADPCM51_FRONTCENTERLOW | \
                             XMV_AUDIO_ADPCM51_REARLEFTRIGHT)
@@@ -207,15 -217,15 +208,15 @@@ static int xmv_read_header(AVFormatCont
              return AVERROR(ENOMEM);
  
          ast->codec->codec_type            = AVMEDIA_TYPE_AUDIO;
 -        ast->codec->codec_id              = track->codec_id;
 -        ast->codec->codec_tag             = track->compression;
 -        ast->codec->channels              = track->channels;
 -        ast->codec->sample_rate           = track->sample_rate;
 -        ast->codec->bits_per_coded_sample = track->bits_per_sample;
 -        ast->codec->bit_rate              = track->bit_rate;
 -        ast->codec->block_align           = 36 * track->channels;
 +        ast->codec->codec_id              = packet->codec_id;
 +        ast->codec->codec_tag             = packet->compression;
 +        ast->codec->channels              = packet->channels;
 +        ast->codec->sample_rate           = packet->sample_rate;
 +        ast->codec->bits_per_coded_sample = packet->bits_per_sample;
 +        ast->codec->bit_rate              = packet->bit_rate;
 +        ast->codec->block_align           = 36 * packet->channels;
  
-         av_set_pts_info(ast, 32, packet->block_samples, packet->sample_rate);
 -        avpriv_set_pts_info(ast, 32, track->block_samples, track->sample_rate);
++        avpriv_set_pts_info(ast, 32, packet->block_samples, packet->sample_rate);
  
          packet->stream_index = ast->index;
  
Simple merge
Simple merge
Simple merge