Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 23 Nov 2011 03:02:17 +0000 (04:02 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 23 Nov 2011 03:02:17 +0000 (04:02 +0100)
* qatar/master: (22 commits)
  aacdec: Fix PS in ADTS.
  avconv: Consistently use PIX_FMT_NONE.
  dsputil: use cpuflags in x86 emu_edge_core
  dsputil: use movups instead of movdqu in ff_emu_edge_core_sse()
  wma: initialize prev_block_len_bits, next_block_len_bits, and block_len_bits.
  mov: Remove some redundant and obsolete comments.
  Add libavutil/mathematics.h #includes for INFINITY
  doxy: structure libavformat groups
  doxy: introduce an empty structure in libavcodec
  doxy: provide a start page and document libavutil
  doxy: cleanup pixfmt.h
  regtest: split video encode/decode tests into individual targets
  ARM: add explicit .arch and .fpu directives to asm.S
  pthread: do not touch has_b_frames
  avconv: cleanup the transcoding loop in output_packet().
  avconv: split subtitle transcoding out of output_packet().
  avconv: split video transcoding out of output_packet().
  avconv: split audio transcoding out of output_packet().
  avconv: reindent.
  avconv: move streamcopy-only code out of decoding loop.
  ...

Conflicts:
avconv.c
libavcodec/aaccoder.c
libavcodec/pthread.c
libavcodec/version.h
libavutil/audioconvert.h
libavutil/avutil.h
libavutil/mem.h
tests/ref/vsynth1/dv
tests/ref/vsynth1/mpeg2thread
tests/ref/vsynth2/dv
tests/ref/vsynth2/mpeg2thread

Merged-by: Michael Niedermayer <michaelni@gmx.at>
45 files changed:
1  2 
avconv.c
cmdutils.c
configure
ffmpeg.c
libavcodec/aaccoder.c
libavcodec/aacdec.c
libavcodec/arm/asm.S
libavcodec/avcodec.h
libavcodec/nellymoserenc.c
libavcodec/pthread.c
libavcodec/version.h
libavcodec/wma.c
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/dsputil_yasm.asm
libavformat/avformat.h
libavformat/mov.c
libavutil/adler32.h
libavutil/aes.h
libavutil/audioconvert.h
libavutil/avstring.h
libavutil/avutil.h
libavutil/base64.h
libavutil/dict.h
libavutil/error.h
libavutil/imgutils.h
libavutil/intmath.h
libavutil/lzo.h
libavutil/mathematics.h
libavutil/md5.h
libavutil/mem.h
libavutil/opt.h
libavutil/pixfmt.h
libavutil/random_seed.h
libavutil/rational.h
libavutil/sha.h
libavutil/tree.h
tests/codec-regression.sh
tests/ref/vsynth1/dv
tests/ref/vsynth1/dv_411
tests/ref/vsynth1/mpeg2thread
tests/ref/vsynth1/mpeg2thread_ilace
tests/ref/vsynth2/dv
tests/ref/vsynth2/dv_411
tests/ref/vsynth2/mpeg2thread
tests/ref/vsynth2/mpeg2thread_ilace

diff --cc avconv.c
+++ b/avconv.c
@@@ -1596,6 -1528,316 +1596,327 @@@ static void flush_encoders(OutputStrea
      }
  }
  
 -    ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
 -                                                 decoded_frame->pkt_dts);
+ /*
+  * 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;
+     pkt->data   += ret;
+     pkt->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 */
+         return 0;
+     }
+     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;
+         }
+         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;
+         }
+         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;
+         }
+         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);
+         }
+     }
+     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_audio_out(output_files[ost->file_index].ctx, ost, ist,
+                      decoded_data_buf, decoded_data_size);
+     }
+     return 0;
+ }
+ static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
+ {
+     AVFrame *decoded_frame, *filtered_frame = NULL;
+     void *buffer_to_free = NULL;
+     int i, ret = 0;
+     float quality;
+ #if CONFIG_AVFILTER
+     int frame_available = 1;
+ #endif
+     if (!(decoded_frame = avcodec_alloc_frame()))
+         return AVERROR(ENOMEM);
+     pkt->pts  = *pkt_pts;
+     pkt->dts  = ist->pts;
+     *pkt_pts  = AV_NOPTS_VALUE;
+     ret = avcodec_decode_video2(ist->st->codec,
+                                 decoded_frame, got_output, pkt);
+     if (ret < 0)
+         goto fail;
+     quality = same_quant ? decoded_frame->quality : 0;
+     if (!*got_output) {
+         /* no picture yet */
+         av_freep(&decoded_frame);
+         return 0;
+     }
 -            AVRational sar;
 -            if (ist->st->sample_aspect_ratio.num)
 -                sar = ist->st->sample_aspect_ratio;
 -            else
 -                sar = ist->st->codec->sample_aspect_ratio;
 -            av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
++    ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
+     if (ist->st->codec->time_base.num != 0) {
+         int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
+                                            ist->st->codec->ticks_per_frame;
+         ist->next_pts += ((int64_t)AV_TIME_BASE *
+                           ist->st->codec->time_base.num * ticks) /
+                           ist->st->codec->time_base.den;
+     }
+     pkt->size = 0;
+     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
+     rate_emu_sleep(ist);
+     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) {
 -            AVRational ist_pts_tb;
 -            if (ost->output_video_filter)
 -                get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
 -            if (ost->picref)
 -                ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
++            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);
+             if (!(filtered_frame = avcodec_alloc_frame())) {
+                 ret = AVERROR(ENOMEM);
+                 goto fail;
+             }
+             frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
+         }
+         while (frame_available) {
 -                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
++            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 (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]);
+             if (ost->picref)
+                 avfilter_unref_buffer(ost->picref);
+         }
+         av_freep(&filtered_frame);
+ #endif
+     }
+ fail:
+     av_free(buffer_to_free);
+     av_freep(&decoded_frame);
+     return ret;
+ }
+ static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
+ {
+     AVSubtitle subtitle;
+     int i, ret = avcodec_decode_subtitle2(ist->st->codec,
+                                           &subtitle, got_output, pkt);
+     if (ret < 0)
+         return ret;
+     if (!*got_output)
+         return 0;
+     pkt->size = 0;
+     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 0;
+ }
  /* pkt = NULL means EOF (needed to flush decoder buffers) */
  static int output_packet(InputStream *ist, int ist_index,
                           OutputStream *ost_table, int nb_ostreams,
diff --cc cmdutils.c
Simple merge
diff --cc configure
Simple merge
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -770,11 -621,11 +770,11 @@@ static void choose_pixel_fmt(AVStream *
                  p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
              }
          }
--        for(; *p!=-1; p++){
++        for (; *p != PIX_FMT_NONE; p++) {
              if(*p == st->codec->pix_fmt)
                  break;
          }
--        if (*p == -1) {
++        if (*p == PIX_FMT_NONE) {
              if(st->codec->pix_fmt != PIX_FMT_NONE)
                  av_log(NULL, AV_LOG_WARNING,
                          "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
@@@ -1536,490 -1449,454 +1536,528 @@@ static void generate_silence(uint8_t *b
      memset(buf, fill_char, size);
  }
  
 -/* 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)
 +static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
  {
 -    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;
 +    int i, ret;
  
 -    AVPacket avpkt;
 -    int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
 +    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;
  
 -    if(ist->next_pts == AV_NOPTS_VALUE)
 -        ist->next_pts= ist->pts;
 +        if (!ost->encoding_needed)
 +            continue;
  
 -    if (pkt == NULL) {
 -        /* EOF handling */
 -        av_init_packet(&avpkt);
 -        avpkt.data = NULL;
 -        avpkt.size = 0;
 -        goto handle_eof;
 -    } else {
 -        avpkt = *pkt;
 -    }
 +        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(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);
 -
 -    //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;
++    pkt->data   += ret;
++    pkt->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 */
++        return 0;
++    }
++
++    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:
++        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);
++        }
++    }
++
++    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_audio_out(output_files[ost->file_index].ctx, ost, ist,
++                     decoded_data_buf, decoded_data_size);
++    }
++    return 0;
++}
++
++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
 -                            if (ost->picref->video && !ost->frame_aspect_ratio)
 -                                ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
++    int frame_available = 1;
+ #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);
 -                        av_init_packet(&opkt);
++    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) {
++        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;
 -                        if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
 -#if !CONFIG_AVFILTER
 -                            continue;
 -#else
 -                            goto cont;
 -#endif
++    ret = avcodec_decode_video2(ist->st->codec,
++                                decoded_frame, got_output, pkt);
++    if (ret < 0)
++        goto fail;
 -                        /* no reencoding needed : output the packet directly */
 -                        /* force the input stream PTS */
++    quality = same_quant ? decoded_frame->quality : 0;
++    if (!*got_output) {
++        /* no picture yet */
++        av_freep(&decoded_frame);
++        return 0;
++    }
 -                        avcodec_get_frame_defaults(&avframe);
 -                        ost->st->codec->coded_frame= &avframe;
 -                        avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
++    if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
++        ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
 -                        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++;
 -                        }
++    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;
 -                        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;
 -                        }
++    pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
 -                        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
 -                }
++    for(i=0;i<nb_output_streams;i++) {
++        OutputFile *of = &output_files[output_streams[i].file_index];
++            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);
+             }
 -
 -        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;
 -        }
+     }
 - 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 0;
 -    av_sdp_create(avc, n, sdp, sizeof(sdp));
 -    printf("SDP:\n%s\n", sdp);
 -    fflush(stdout);
++    pkt->size = 0;
++
++    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 0;
+ }
 -static int copy_chapters(int infile, int outfile)
 +/* 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;
 -    AVFormatContext *is = input_files[infile].ctx;
 -    AVFormatContext *os = output_files[outfile];
 -    int i;
 +    OutputStream *ost;
 +    int ret = 0, i;
 +    int got_output;
-     void *buffer_to_free = NULL;
-     static unsigned int samples_size= 0;
-     AVSubtitle subtitle, *subtitle_to_free;
 +    int64_t pkt_dts = AV_NOPTS_VALUE;
 +    int64_t pkt_pts = AV_NOPTS_VALUE;
- #if CONFIG_AVFILTER
-     int frame_available;
- #endif
-     float quality = 0;
  
 -    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;
-     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
  
 +    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 (avpkt.size > 0 || (!pkt && got_output)) {
-         uint8_t *data_buf, *decoded_data_buf;
-         int data_size, decoded_data_size;
-         AVFrame *decoded_frame, *filtered_frame;
++    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;
 +
-         /* decode the packet if needed */
-         decoded_frame    = filtered_frame = NULL;
-         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 * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
-                     samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
-                     av_free(samples);
-                     samples= av_malloc(samples_size);
-                 }
-                 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;
-                 }
-                 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:
-                     if (!(decoded_frame = avcodec_alloc_frame()))
-                         return AVERROR(ENOMEM);
-                     avpkt.pts = pkt_pts;
-                     avpkt.dts = pkt_dts;
-                     pkt_pts = AV_NOPTS_VALUE;
-                     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;
-                     ret = avcodec_decode_video2(ist->st->codec,
-                                                 decoded_frame, &got_output, &avpkt);
-                     quality = same_quant ? decoded_frame->quality : 0;
-                     if (ret < 0)
-                         goto fail;
-                     if (!got_output) {
-                         /* no picture yet */
-                         av_freep(&decoded_frame);
-                         goto discard_packet;
-                     }
-                     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) {
-                         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 *)decoded_frame, &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;
-                 }
-                 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;
-                 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;
-             }
-             avpkt.size = 0;
++        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;
 +        }
  
- #if CONFIG_AVFILTER
-         if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
-         for(i=0;i<nb_ostreams;i++) {
-             OutputFile *of = &output_files[ost_table[i].file_index];
-             if (of->start_time == 0 || ist->pts >= of->start_time) {
-                 ost = &ost_table[i];
-                 if (ost->input_video_filter && ost->source_index == ist_index) {
-                     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);
-                 }
-             }
 -        out_ch = av_mallocz(sizeof(AVChapter));
 -        if (!out_ch)
 -            return AVERROR(ENOMEM);
++        if (ret < 0)
++            return ret;
++        if (!got_output) {
++            if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
++                continue;
++            goto discard_packet;
 +        }
- #endif
++    }
++ discard_packet:
  
-         // preprocess audio (volume)
-         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
-             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;
-                 }
-                 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;
-                 }
-                 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;
-                 }
-                 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);
-                 }
 -        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);
++        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++) {
++        ost = &ost_table[i];
  
-         /* frame rate emulation */
-         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);
-         }
-         /* if output time reached then transcode raw format,
-            encode packets and output them */
-         for (i = 0; i < nb_ostreams; i++) {
-             OutputFile *of = &output_files[ost_table[i].file_index];
-             int frame_size;
-             ost = &ost_table[i];
-             if (ost->source_index != ist_index)
-                 continue;
-             if (of->start_time && ist->pts < of->start_time)
-                 continue;
-             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;
-                 continue;
-             }
- #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) {
-                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
-                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
-                     if (av_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);
-                     }
-                 }
- #else
-                 filtered_frame = decoded_frame;
- #endif
-                 os = output_files[ost->file_index].ctx;
-                 /* 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->sample_aspect_ratio;
- #endif
-                         do_video_out(os, ost, ist, filtered_frame, &frame_size,
-                                      same_quant ? 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 {
-                     AVPicture pict;
-                     AVPacket opkt;
-                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
-                     av_init_packet(&opkt);
-                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
-                         !ost->copy_initial_nonkeyframes)
- #if !CONFIG_AVFILTER
-                         continue;
- #else
-                         goto cont;
- #endif
-                     /* no reencoding needed : output the packet directly */
-                     /* force the input stream PTS */
-                     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++;
-                     }
-                     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 (os->oformat->flags & AVFMT_RAWPICTURE) {
-                         /* store AVPicture in AVPacket, as expected by the output format */
-                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
-                         opkt.data = (uint8_t *)&pict;
-                         opkt.size = sizeof(AVPicture);
-                         opkt.flags |= AV_PKT_FLAG_KEY;
-                     }
-                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
-                     ost->st->codec->frame_number++;
-                     ost->frame_number++;
-                     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]);
-                 avfilter_unref_buffer(ost->picref);
-             }
-             av_freep(&filtered_frame);
- #endif
-         }
 -        if (metadata_chapters_autocopy)
 -            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
++        if (!check_output_constraints(ist, ost) || ost->encoding_needed)
++            continue;
  
- fail:
-         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;
-         }
-         av_freep(&decoded_frame);
-         if (ret < 0)
-             return ret;
 -        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);
      }
-  discard_packet:
 +
      return 0;
  }
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -365,8 -363,7 +365,8 @@@ static int update_context_from_thread(A
      }
  
      if (for_user) {
-         dst->delay         = src->thread_count - 1;
-         dst->coded_frame   = src->coded_frame;
++        dst->delay       = src->thread_count - 1;
+         dst->coded_frame = src->coded_frame;
      } else {
          if (dst->codec->update_thread_context)
              err = dst->codec->update_thread_context(dst, src);
@@@ -21,7 -21,7 +21,7 @@@
  #define AVCODEC_VERSION_H
  
  #define LIBAVCODEC_VERSION_MAJOR 53
- #define LIBAVCODEC_VERSION_MINOR 36
 -#define LIBAVCODEC_VERSION_MINOR 22
++#define LIBAVCODEC_VERSION_MINOR 37
  #define LIBAVCODEC_VERSION_MICRO  0
  
  #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc libavutil/aes.h
Simple merge
  #define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
  
  /**
+  * @}
+  */
+ /**
   * Return a channel layout id that matches name, 0 if no match.
 + * name can be one or several of the following notations,
 + * separated by '+' or '|':
 + * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0,
 + *   5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
 + * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
 + *   SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
 + * - a number of channels, in decimal, optionnally followed by 'c', yielding
 + *   the default channel layout for that number of channels (@see
 + *   av_get_default_channel_layout);
 + * - a channel layout mask, in hexadecimal starting with "0x" (see the
 + *   AV_CH_* macros).
 + + Example: "stereo+FC" = "2+FC" = "2c+1c" = "0x7"
   */
  int64_t av_get_channel_layout(const char *name);
  
@@@ -105,8 -109,7 +121,12 @@@ void av_get_channel_layout_string(char 
  int av_get_channel_layout_nb_channels(int64_t channel_layout);
  
  /**
 + * Return default channel layout for a given number of channels.
 + */
 +int64_t av_get_default_channel_layout(int nb_channels);
 +
++/**
+  * @}
+  */
  #endif /* AVUTIL_AUDIOCONVERT_H */
@@@ -185,9 -156,9 +190,9 @@@ static inline int av_tolower(int c
      return c;
  }
  
 -/*
 +/**
   * Locale independent case-insensitive compare.
-  * Note: This means only ASCII-range characters are case-insensitive
+  * @note This means only ASCII-range characters are case-insensitive
   */
  int av_strcasecmp(const char *a, const char *b);
  
  #define AV_VERSION_DOT(a, b, c) a ##.## b ##.## c
  #define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
  
+ /**
+  * @}
+  *
+  * @defgroup lavu_ver Version and Build diagnostics
+  *
+  * Macros and function useful to check at compiletime and at runtime
+  * which version of libavutil is in use.
+  *
+  * @{
+  */
  #define LIBAVUTIL_VERSION_MAJOR 51
 -#define LIBAVUTIL_VERSION_MINOR 16
 +#define LIBAVUTIL_VERSION_MINOR 26
  #define LIBAVUTIL_VERSION_MICRO  0
  
  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
  #define LIBAVUTIL_IDENT         "Lavu" AV_STRINGIFY(LIBAVUTIL_VERSION)
  
  /**
+  * @}
+  *
+  * @defgroup depr_guards Deprecation guards
   * Those FF_API_* defines are not part of public API.
   * They may change, break or disappear at any time.
+  *
+  * They are used mostly internally to mark code that will be removed
+  * on the next major version.
+  *
+  * @{
   */
 +#ifndef FF_API_OLD_EVAL_NAMES
 +#define FF_API_OLD_EVAL_NAMES (LIBAVUTIL_VERSION_MAJOR < 52)
 +#endif
  #ifndef FF_API_GET_BITS_PER_SAMPLE_FMT
  #define FF_API_GET_BITS_PER_SAMPLE_FMT (LIBAVUTIL_VERSION_MAJOR < 52)
  #endif
@@@ -99,11 -235,15 +238,21 @@@ enum AVMediaType 
  };
  
  /**
 + * Return a string describing the media_type enum, NULL if media_type
 + * is unknown.
 + */
 +const char *av_get_media_type_string(enum AVMediaType media_type);
 +
++/**
+  * @defgroup lavu_const Constants
+  * @{
+  *
+  * @defgroup lavu_enc Encoding specific
+  *
+  * @note those definition should move to avcodec
+  * @{
+  */
  #define FF_LAMBDA_SHIFT 7
  #define FF_LAMBDA_SCALE (1<<FF_LAMBDA_SHIFT)
  #define FF_QP2LAMBDA 118 ///< factor to convert from H.263 QP to lambda
  
  #define FF_QUALITY_SCALE FF_LAMBDA_SCALE //FIXME maybe remove
  
+ /**
+  * @}
+  * @defgroup lavu_time Timestamp specific
+  *
+  * Libav internal timebase and timestamp definitions
+  *
+  * @{
+  */
+ /**
+  * @brief Undefined timestamp value
+  *
+  * Usually reported by demuxer that work on containers that do not provide
+  * either pts or dts.
+  */
  #define AV_NOPTS_VALUE          INT64_C(0x8000000000000000)
+ /**
+  * Internal time base represented as integer
+  */
  #define AV_TIME_BASE            1000000
+ /**
+  * Internal time base represented as fractional value
+  */
  #define AV_TIME_BASE_Q          (AVRational){1, AV_TIME_BASE}
  
+ /**
+  * @}
+  * @}
+  * @defgroup lavu_picture Image related
+  *
+  * AVPicture types, pixel formats and basic image planes manipulation.
+  *
+  * @{
+  */
  enum AVPictureType {
 -    AV_PICTURE_TYPE_I = 1, ///< Intra
 +    AV_PICTURE_TYPE_NONE = 0, ///< Undefined
 +    AV_PICTURE_TYPE_I,     ///< Intra
      AV_PICTURE_TYPE_P,     ///< Predicted
      AV_PICTURE_TYPE_B,     ///< Bi-dir predicted
      AV_PICTURE_TYPE_S,     ///< S(GMC)-VOP MPEG4
  char av_get_picture_type_char(enum AVPictureType pict_type);
  
  /**
+  * @}
+  */
++/**
 + * Return x default pointer in case p is NULL.
 + */
 +static inline const void *av_x_if_null(const void *p, const void *x)
 +{
 +    return p ? p : x;
 +}
 +
  #include "common.h"
  #include "error.h"
 +#include "mathematics.h"
 +#include "rational.h"
 +#include "intfloat_readwrite.h"
 +#include "log.h"
 +#include "pixfmt.h"
  
+ /**
+  * @}
+  * @}
+  */
  #endif /* AVUTIL_AVUTIL_H */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
diff --cc libavutil/lzo.h
Simple merge
Simple merge
diff --cc libavutil/md5.h
Simple merge
diff --cc libavutil/mem.h
  #define AVUTIL_MEM_H
  
  #include "attributes.h"
 +#include "error.h"
  #include "avutil.h"
  
 -#if defined(__ICC) && _ICC < 1200 || defined(__SUNPRO_C)
+ /**
+  * @addtogroup lavu_mem
+  * @{
+  */
 +#if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1110 || defined(__SUNPRO_C)
      #define DECLARE_ALIGNED(n,t,v)      t __attribute__ ((aligned (n))) v
      #define DECLARE_ASM_CONST(n,t,v)    const t __attribute__ ((aligned (n))) v
  #elif defined(__TI_COMPILER_VERSION__)
@@@ -147,27 -130,7 +153,31 @@@ char *av_strdup(const char *s) av_mallo
  void av_freep(void *ptr);
  
  /**
 + * Add an element to a dynamic array.
 + *
 + * @param tab_ptr Pointer to the array.
 + * @param nb_ptr  Pointer to the number of elements in the array.
 + * @param elem    Element to be added.
 + */
 +void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
 +
 +/**
 + * Multiply two size_t values checking for overflow.
 + * @return  0 if success, AVERROR(EINVAL) if overflow.
 + */
 +static inline int av_size_mult(size_t a, size_t b, size_t *r)
 +{
 +    size_t t = a * b;
 +    /* Hack inspired from glibc: only try the division if nelem and elsize
 +     * are both greater than sqrt(SIZE_MAX). */
 +    if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
 +        return AVERROR(EINVAL);
 +    *r = t;
 +    return 0;
 +}
 +
++/**
+  * @}
+  */
  #endif /* AVUTIL_MEM_H */
diff --cc libavutil/opt.h
Simple merge
Simple merge
  #define AVUTIL_RANDOM_SEED_H
  
  #include <stdint.h>
+ /**
+  * @addtogroup lavu_crypto
+  * @{
+  */
  
  /**
 - * Get random data.
 - *
 - * This function can be called repeatedly to generate more random bits
 - * as needed. It is generally quite slow, and usually used to seed a
 - * PRNG.  As it uses /dev/urandom and /dev/random, the quality of the
 - * returned random data depends on the platform.
 + * Get a seed to use in conjunction with random functions.
 + * This function tries to provide a good seed at a best effort bases.
 + * Its possible to call this function multiple times if more bits are needed.
 + * It can be quite slow, which is why it should only be used as seed for a faster
 + * PRNG. The quality of the seed depends on the platform.
   */
  uint32_t av_get_random_seed(void);
  
Simple merge
diff --cc libavutil/sha.h
Simple merge
Simple merge
Simple merge
@@@ -1,8 -1,4 +1,4 @@@
 -27ade3031b17214cf81c19cbf70f37d7 *./tests/data/vsynth1/dv.dv
 +4d572f758b55a1756adf9f54132f3b9e *./tests/data/vsynth1/dv.dv
  7200000 ./tests/data/vsynth1/dv.dv
  02ac7cdeab91d4d5621e7ce96dddc498 *./tests/data/dv.vsynth1.out.yuv
--stddev:    6.90 PSNR: 31.34 MAXDIFF:   76 bytes:  7603200/  7603200
- f179899efba432c6f01149c36c709092 *./tests/data/vsynth1/dv411.dv
- 7200000 ./tests/data/vsynth1/dv411.dv
- b6640a3a572353f51284acb746eb00c4 *./tests/data/dv.vsynth1.out.yuv
- stddev:   30.76 PSNR: 18.37 MAXDIFF:  205 bytes:  7603200/  7603200
++stddev:    6.90 PSNR: 31.34 MAXDIFF:   76 bytes:  7603200/  7603200
index 0000000,841c3fd..c45b593
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,4 @@@
 -bd67f2431db160d4bb6dcd791cea6efd *./tests/data/vsynth1/dv411.dv
++f179899efba432c6f01149c36c709092 *./tests/data/vsynth1/dv411.dv
+ 7200000 ./tests/data/vsynth1/dv411.dv
+ b6640a3a572353f51284acb746eb00c4 *./tests/data/dv_411.vsynth1.out.yuv
+ stddev:   30.76 PSNR: 18.37 MAXDIFF:  205 bytes:  7603200/  7603200
@@@ -1,12 -1,4 +1,4 @@@
  ecd183706688bd977c9994c3d1b23d61 *./tests/data/vsynth1/mpeg2thread.mpg
  801313 ./tests/data/vsynth1/mpeg2thread.mpg
  d1658911ca83f5616c1d32abc40750de *./tests/data/mpeg2thread.vsynth1.out.yuv
- stddev:    7.63 PSNR: 30.48 MAXDIFF:  110 bytes:  7603200/  7603200
- 23d600b026222253c2340e23300a4c02 *./tests/data/vsynth1/mpeg2threadivlc.mpg
- 791773 ./tests/data/vsynth1/mpeg2threadivlc.mpg
- d1658911ca83f5616c1d32abc40750de *./tests/data/mpeg2thread.vsynth1.out.yuv
--stddev:    7.63 PSNR: 30.48 MAXDIFF:  110 bytes:  7603200/  7603200
- d119fe917dd81d1ff758b4ce684a8d9d *./tests/data/vsynth1/mpeg2reuse.mpg
- 2074636 ./tests/data/vsynth1/mpeg2reuse.mpg
- 92ced6afe8c02304943c400cce51a5f4 *./tests/data/mpeg2thread.vsynth1.out.yuv
- stddev:    7.66 PSNR: 30.44 MAXDIFF:  111 bytes:  7603200/  7603200
++stddev:    7.63 PSNR: 30.48 MAXDIFF:  110 bytes:  7603200/  7603200
index 0000000,0667b68..f9c3339
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,8 @@@
+ 23d600b026222253c2340e23300a4c02 *./tests/data/vsynth1/mpeg2threadivlc.mpg
+ 791773 ./tests/data/vsynth1/mpeg2threadivlc.mpg
+ d1658911ca83f5616c1d32abc40750de *./tests/data/mpeg2thread_ilace.vsynth1.out.yuv
+ stddev:    7.63 PSNR: 30.48 MAXDIFF:  110 bytes:  7603200/  7603200
++d119fe917dd81d1ff758b4ce684a8d9d *./tests/data/vsynth1/mpeg2reuse.mpg
++2074636 ./tests/data/vsynth1/mpeg2reuse.mpg
++92ced6afe8c02304943c400cce51a5f4 *./tests/data/mpeg2thread_ilace.vsynth1.out.yuv
++stddev:    7.66 PSNR: 30.44 MAXDIFF:  111 bytes:  7603200/  7603200
@@@ -1,8 -1,4 +1,4 @@@
 -bfa766f89bfeabc0ae1044f3954bed52 *./tests/data/vsynth2/dv.dv
 +85b8d55b0b68bb3fc2e90babb580f9b7 *./tests/data/vsynth2/dv.dv
  7200000 ./tests/data/vsynth2/dv.dv
  7ec62bd3350a6848364669e6e1e4b9cc *./tests/data/dv.vsynth2.out.yuv
--stddev:    1.71 PSNR: 43.47 MAXDIFF:   33 bytes:  7603200/  7603200
- e428508f400327aeb96969c08fb9e1b5 *./tests/data/vsynth2/dv411.dv
- 7200000 ./tests/data/vsynth2/dv411.dv
- 7f9fa421028aabb11eaf4c6513a5a843 *./tests/data/dv.vsynth2.out.yuv
- stddev:   10.09 PSNR: 28.05 MAXDIFF:   60 bytes:  7603200/  7603200
++stddev:    1.71 PSNR: 43.47 MAXDIFF:   33 bytes:  7603200/  7603200
index 0000000,2340ef0..708ac88
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,4 @@@
 -00a9d8683ac6826af41bcf7223fb0389 *./tests/data/vsynth2/dv411.dv
++e428508f400327aeb96969c08fb9e1b5 *./tests/data/vsynth2/dv411.dv
+ 7200000 ./tests/data/vsynth2/dv411.dv
+ 7f9fa421028aabb11eaf4c6513a5a843 *./tests/data/dv_411.vsynth2.out.yuv
+ stddev:   10.09 PSNR: 28.05 MAXDIFF:   60 bytes:  7603200/  7603200
@@@ -1,12 -1,4 +1,4 @@@
  889c754a42d7689b228853e1ece6d345 *./tests/data/vsynth2/mpeg2thread.mpg
  179650 ./tests/data/vsynth2/mpeg2thread.mpg
  8c6a7ed2eb73bd18fd2bb9829464100d *./tests/data/mpeg2thread.vsynth2.out.yuv
- stddev:    4.72 PSNR: 34.65 MAXDIFF:   72 bytes:  7603200/  7603200
- 10b900e32809758857c596d56746e00e *./tests/data/vsynth2/mpeg2threadivlc.mpg
- 178801 ./tests/data/vsynth2/mpeg2threadivlc.mpg
- 8c6a7ed2eb73bd18fd2bb9829464100d *./tests/data/mpeg2thread.vsynth2.out.yuv
--stddev:    4.72 PSNR: 34.65 MAXDIFF:   72 bytes:  7603200/  7603200
- 864d6bf2982a61e510003a518be65a2d *./tests/data/vsynth2/mpeg2reuse.mpg
- 383419 ./tests/data/vsynth2/mpeg2reuse.mpg
- bb20fa080cfd2b0a687ea7376ff4f902 *./tests/data/mpeg2thread.vsynth2.out.yuv
- stddev:    4.73 PSNR: 34.63 MAXDIFF:   72 bytes:  7603200/  7603200
++stddev:    4.72 PSNR: 34.65 MAXDIFF:   72 bytes:  7603200/  7603200
index 0000000,1320db9..f074d44
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,4 +1,8 @@@
+ 10b900e32809758857c596d56746e00e *./tests/data/vsynth2/mpeg2threadivlc.mpg
+ 178801 ./tests/data/vsynth2/mpeg2threadivlc.mpg
+ 8c6a7ed2eb73bd18fd2bb9829464100d *./tests/data/mpeg2thread_ilace.vsynth2.out.yuv
+ stddev:    4.72 PSNR: 34.65 MAXDIFF:   72 bytes:  7603200/  7603200
++864d6bf2982a61e510003a518be65a2d *./tests/data/vsynth2/mpeg2reuse.mpg
++383419 ./tests/data/vsynth2/mpeg2reuse.mpg
++bb20fa080cfd2b0a687ea7376ff4f902 *./tests/data/mpeg2thread_ilace.vsynth2.out.yuv
++stddev:    4.73 PSNR: 34.63 MAXDIFF:   72 bytes:  7603200/  7603200