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
+++ 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
+++ 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
   */
  
  #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;
  
@@@ -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"
@@@ -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;
@@@ -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
@@@ -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);
@@@ -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
@@@ -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>
   * 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>
@@@ -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) {
@@@ -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
  #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
  
  #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
@@@ -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
@@@ -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
@@@ -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
@@@ -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
@@@ -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
@@@ -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
@@@ -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
@@@ -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
  
  #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
@@@ -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
@@@ -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
  #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