"Fossies" - the Fresh Open Source Software Archive

Member "libav-12.3/avconv.c" (12 Feb 2018, 91322 Bytes) of package /linux/misc/libav-12.3.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "avconv.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 12.2_vs_12.3.

    1 /*
    2  * avconv main
    3  * Copyright (c) 2000-2011 The Libav developers
    4  *
    5  * This file is part of Libav.
    6  *
    7  * Libav is free software; you can redistribute it and/or
    8  * modify it under the terms of the GNU Lesser General Public
    9  * License as published by the Free Software Foundation; either
   10  * version 2.1 of the License, or (at your option) any later version.
   11  *
   12  * Libav is distributed in the hope that it will be useful,
   13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   15  * Lesser General Public License for more details.
   16  *
   17  * You should have received a copy of the GNU Lesser General Public
   18  * License along with Libav; if not, write to the Free Software
   19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   20  */
   21 
   22 #include "config.h"
   23 #include <ctype.h>
   24 #include <string.h>
   25 #include <math.h>
   26 #include <stdlib.h>
   27 #include <errno.h>
   28 #include <signal.h>
   29 #include <limits.h>
   30 #include <stdint.h>
   31 
   32 #include "libavformat/avformat.h"
   33 #include "libavdevice/avdevice.h"
   34 #include "libswscale/swscale.h"
   35 #include "libavresample/avresample.h"
   36 #include "libavutil/opt.h"
   37 #include "libavutil/channel_layout.h"
   38 #include "libavutil/parseutils.h"
   39 #include "libavutil/samplefmt.h"
   40 #include "libavutil/fifo.h"
   41 #include "libavutil/internal.h"
   42 #include "libavutil/intreadwrite.h"
   43 #include "libavutil/dict.h"
   44 #include "libavutil/mathematics.h"
   45 #include "libavutil/pixdesc.h"
   46 #include "libavutil/avstring.h"
   47 #include "libavutil/libm.h"
   48 #include "libavutil/imgutils.h"
   49 #include "libavutil/time.h"
   50 #include "libavformat/os_support.h"
   51 
   52 # include "libavfilter/avfilter.h"
   53 # include "libavfilter/buffersrc.h"
   54 # include "libavfilter/buffersink.h"
   55 
   56 #if HAVE_SYS_RESOURCE_H
   57 #include <sys/time.h>
   58 #include <sys/types.h>
   59 #include <sys/resource.h>
   60 #elif HAVE_GETPROCESSTIMES
   61 #include <windows.h>
   62 #endif
   63 #if HAVE_GETPROCESSMEMORYINFO
   64 #include <windows.h>
   65 #include <psapi.h>
   66 #endif
   67 
   68 #if HAVE_SYS_SELECT_H
   69 #include <sys/select.h>
   70 #endif
   71 
   72 #if HAVE_PTHREADS
   73 #include <pthread.h>
   74 #endif
   75 
   76 #include <time.h>
   77 
   78 #include "avconv.h"
   79 #include "cmdutils.h"
   80 
   81 #include "libavutil/avassert.h"
   82 
   83 const char program_name[] = "avconv";
   84 const int program_birth_year = 2000;
   85 
   86 static FILE *vstats_file;
   87 
   88 static int nb_frames_drop = 0;
   89 
   90 static int want_sdp = 1;
   91 
   92 #if HAVE_PTHREADS
   93 /* signal to input threads that they should exit; set by the main thread */
   94 static int transcoding_finished;
   95 #endif
   96 
   97 InputStream **input_streams = NULL;
   98 int        nb_input_streams = 0;
   99 InputFile   **input_files   = NULL;
  100 int        nb_input_files   = 0;
  101 
  102 OutputStream **output_streams = NULL;
  103 int         nb_output_streams = 0;
  104 OutputFile   **output_files   = NULL;
  105 int         nb_output_files   = 0;
  106 
  107 FilterGraph **filtergraphs;
  108 int        nb_filtergraphs;
  109 
  110 static void term_exit(void)
  111 {
  112     av_log(NULL, AV_LOG_QUIET, "");
  113 }
  114 
  115 static volatile int received_sigterm = 0;
  116 static volatile int received_nb_signals = 0;
  117 
  118 static void
  119 sigterm_handler(int sig)
  120 {
  121     received_sigterm = sig;
  122     received_nb_signals++;
  123     term_exit();
  124 }
  125 
  126 static void term_init(void)
  127 {
  128     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).    */
  129     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
  130 #ifdef SIGXCPU
  131     signal(SIGXCPU, sigterm_handler);
  132 #endif
  133 }
  134 
  135 static int decode_interrupt_cb(void *ctx)
  136 {
  137     return received_nb_signals > 1;
  138 }
  139 
  140 const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
  141 
  142 static void avconv_cleanup(int ret)
  143 {
  144     int i, j;
  145 
  146     for (i = 0; i < nb_filtergraphs; i++) {
  147         FilterGraph *fg = filtergraphs[i];
  148         avfilter_graph_free(&fg->graph);
  149         for (j = 0; j < fg->nb_inputs; j++) {
  150             while (av_fifo_size(fg->inputs[j]->frame_queue)) {
  151                 AVFrame *frame;
  152                 av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
  153                                      sizeof(frame), NULL);
  154                 av_frame_free(&frame);
  155             }
  156             av_fifo_free(fg->inputs[j]->frame_queue);
  157             av_buffer_unref(&fg->inputs[j]->hw_frames_ctx);
  158             av_freep(&fg->inputs[j]->name);
  159             av_freep(&fg->inputs[j]);
  160         }
  161         av_freep(&fg->inputs);
  162         for (j = 0; j < fg->nb_outputs; j++) {
  163             av_freep(&fg->outputs[j]->name);
  164             av_freep(&fg->outputs[j]->formats);
  165             av_freep(&fg->outputs[j]->channel_layouts);
  166             av_freep(&fg->outputs[j]->sample_rates);
  167             av_freep(&fg->outputs[j]);
  168         }
  169         av_freep(&fg->outputs);
  170         av_freep(&fg->graph_desc);
  171 
  172         av_freep(&filtergraphs[i]);
  173     }
  174     av_freep(&filtergraphs);
  175 
  176     /* close files */
  177     for (i = 0; i < nb_output_files; i++) {
  178         OutputFile *of = output_files[i];
  179         AVFormatContext *s = of->ctx;
  180         if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
  181             avio_close(s->pb);
  182         avformat_free_context(s);
  183         av_dict_free(&of->opts);
  184 
  185         av_freep(&output_files[i]);
  186     }
  187     for (i = 0; i < nb_output_streams; i++) {
  188         OutputStream *ost = output_streams[i];
  189 
  190         for (j = 0; j < ost->nb_bitstream_filters; j++)
  191             av_bsf_free(&ost->bsf_ctx[j]);
  192         av_freep(&ost->bsf_ctx);
  193         av_freep(&ost->bitstream_filters);
  194 
  195         av_frame_free(&ost->filtered_frame);
  196 
  197         av_parser_close(ost->parser);
  198         avcodec_free_context(&ost->parser_avctx);
  199 
  200         av_freep(&ost->forced_keyframes);
  201         av_freep(&ost->avfilter);
  202         av_freep(&ost->logfile_prefix);
  203 
  204         avcodec_free_context(&ost->enc_ctx);
  205 
  206         if (ost->muxing_queue) {
  207             while (av_fifo_size(ost->muxing_queue)) {
  208                 AVPacket pkt;
  209                 av_log(NULL, AV_LOG_INFO, "after av_fifo_size()\n");
  210                 av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
  211                 av_packet_unref(&pkt);
  212             }
  213             av_fifo_free(ost->muxing_queue);
  214         }
  215         av_freep(&output_streams[i]);
  216     }
  217     for (i = 0; i < nb_input_files; i++) {
  218         avformat_close_input(&input_files[i]->ctx);
  219         av_freep(&input_files[i]);
  220     }
  221     for (i = 0; i < nb_input_streams; i++) {
  222         InputStream *ist = input_streams[i];
  223 
  224         av_frame_free(&ist->decoded_frame);
  225         av_frame_free(&ist->filter_frame);
  226         av_dict_free(&ist->decoder_opts);
  227         av_freep(&ist->filters);
  228         av_freep(&ist->hwaccel_device);
  229 
  230         avcodec_free_context(&ist->dec_ctx);
  231 
  232         av_freep(&input_streams[i]);
  233     }
  234 
  235     if (vstats_file)
  236         fclose(vstats_file);
  237     av_free(vstats_filename);
  238 
  239     av_freep(&input_streams);
  240     av_freep(&input_files);
  241     av_freep(&output_streams);
  242     av_freep(&output_files);
  243 
  244     uninit_opts();
  245 
  246     avformat_network_deinit();
  247 
  248     if (received_sigterm) {
  249         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
  250                (int) received_sigterm);
  251         exit (255);
  252     }
  253 }
  254 
  255 void assert_avoptions(AVDictionary *m)
  256 {
  257     AVDictionaryEntry *t;
  258     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
  259         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
  260         exit_program(1);
  261     }
  262 }
  263 
  264 static void abort_codec_experimental(AVCodec *c, int encoder)
  265 {
  266     const char *codec_string = encoder ? "encoder" : "decoder";
  267     AVCodec *codec;
  268     av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
  269             "results.\nAdd '-strict experimental' if you want to use it.\n",
  270             codec_string, c->name);
  271     codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id);
  272     if (!(codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
  273         av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
  274                codec_string, codec->name);
  275     exit_program(1);
  276 }
  277 
  278 static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
  279 {
  280     AVFormatContext *s = of->ctx;
  281     AVStream *st = ost->st;
  282     int ret;
  283 
  284     if (!of->header_written) {
  285         AVPacket tmp_pkt;
  286         /* the muxer is not initialized yet, buffer the packet */
  287         if (!av_fifo_space(ost->muxing_queue)) {
  288             int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
  289                                  ost->max_muxing_queue_size);
  290             if (new_size <= av_fifo_size(ost->muxing_queue)) {
  291                 av_log(NULL, AV_LOG_ERROR,
  292                        "Too many packets buffered for output stream %d:%d.\n",
  293                        ost->file_index, ost->st->index);
  294                 exit_program(1);
  295             }
  296             ret = av_fifo_realloc2(ost->muxing_queue, new_size);
  297             if (ret < 0)
  298                 exit_program(1);
  299         }
  300         av_packet_move_ref(&tmp_pkt, pkt);
  301         av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
  302         return;
  303     }
  304 
  305     /*
  306      * Audio encoders may split the packets --  #frames in != #packets out.
  307      * But there is no reordering, so we can limit the number of output packets
  308      * by simply dropping them here.
  309      * Counting encoded video frames needs to be done separately because of
  310      * reordering, see do_video_out()
  311      */
  312     if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed)) {
  313         if (ost->frame_number >= ost->max_frames) {
  314             av_packet_unref(pkt);
  315             return;
  316         }
  317         ost->frame_number++;
  318     }
  319     if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
  320         uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
  321                                               NULL);
  322         ost->quality = sd ? *(int *)sd : -1;
  323 
  324         if (ost->frame_rate.num) {
  325             pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
  326                                          ost->mux_timebase);
  327         }
  328     }
  329 
  330     if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
  331         ost->last_mux_dts != AV_NOPTS_VALUE &&
  332         pkt->dts < ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT)) {
  333         av_log(NULL, AV_LOG_WARNING, "Non-monotonous DTS in output stream "
  334                "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
  335                ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
  336         if (exit_on_error) {
  337             av_log(NULL, AV_LOG_FATAL, "aborting.\n");
  338             exit_program(1);
  339         }
  340         av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result "
  341                "in incorrect timestamps in the output file.\n",
  342                ost->last_mux_dts + 1);
  343         pkt->dts = ost->last_mux_dts + 1;
  344         if (pkt->pts != AV_NOPTS_VALUE)
  345             pkt->pts = FFMAX(pkt->pts, pkt->dts);
  346     }
  347     ost->last_mux_dts = pkt->dts;
  348 
  349     ost->data_size += pkt->size;
  350     ost->packets_written++;
  351 
  352     pkt->stream_index = ost->index;
  353     av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
  354 
  355     ret = av_interleaved_write_frame(s, pkt);
  356     if (ret < 0) {
  357         print_error("av_interleaved_write_frame()", ret);
  358         exit_program(1);
  359     }
  360 }
  361 
  362 static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost)
  363 {
  364     int ret = 0;
  365 
  366     /* apply the output bitstream filters, if any */
  367     if (ost->nb_bitstream_filters) {
  368         int idx;
  369 
  370         ret = av_bsf_send_packet(ost->bsf_ctx[0], pkt);
  371         if (ret < 0)
  372             goto finish;
  373 
  374         idx = 1;
  375         while (idx) {
  376             /* get a packet from the previous filter up the chain */
  377             ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
  378             if (ret == AVERROR(EAGAIN)) {
  379                 ret = 0;
  380                 idx--;
  381                 continue;
  382             } else if (ret < 0)
  383                 goto finish;
  384 
  385             /* send it to the next filter down the chain or to the muxer */
  386             if (idx < ost->nb_bitstream_filters) {
  387                 ret = av_bsf_send_packet(ost->bsf_ctx[idx], pkt);
  388                 if (ret < 0)
  389                     goto finish;
  390                 idx++;
  391             } else
  392                 write_packet(of, pkt, ost);
  393         }
  394     } else
  395         write_packet(of, pkt, ost);
  396 
  397 finish:
  398     if (ret < 0 && ret != AVERROR_EOF) {
  399         av_log(NULL, AV_LOG_FATAL, "Error applying bitstream filters to an output "
  400                "packet for stream #%d:%d.\n", ost->file_index, ost->index);
  401         exit_program(1);
  402     }
  403 }
  404 
  405 static int check_recording_time(OutputStream *ost)
  406 {
  407     OutputFile *of = output_files[ost->file_index];
  408 
  409     if (of->recording_time != INT64_MAX &&
  410         av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,
  411                       AV_TIME_BASE_Q) >= 0) {
  412         ost->finished = 1;
  413         return 0;
  414     }
  415     return 1;
  416 }
  417 
  418 static void do_audio_out(OutputFile *of, OutputStream *ost,
  419                          AVFrame *frame)
  420 {
  421     AVCodecContext *enc = ost->enc_ctx;
  422     AVPacket pkt;
  423     int ret;
  424 
  425     av_init_packet(&pkt);
  426     pkt.data = NULL;
  427     pkt.size = 0;
  428 
  429     if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
  430         frame->pts = ost->sync_opts;
  431     ost->sync_opts = frame->pts + frame->nb_samples;
  432 
  433     ost->samples_encoded += frame->nb_samples;
  434     ost->frames_encoded++;
  435 
  436     ret = avcodec_send_frame(enc, frame);
  437     if (ret < 0)
  438         goto error;
  439 
  440     while (1) {
  441         ret = avcodec_receive_packet(enc, &pkt);
  442         if (ret == AVERROR(EAGAIN))
  443             break;
  444         if (ret < 0)
  445             goto error;
  446 
  447         output_packet(of, &pkt, ost);
  448     }
  449 
  450     return;
  451 error:
  452     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
  453     exit_program(1);
  454 }
  455 
  456 static void do_subtitle_out(OutputFile *of,
  457                             OutputStream *ost,
  458                             InputStream *ist,
  459                             AVSubtitle *sub,
  460                             int64_t pts)
  461 {
  462     static uint8_t *subtitle_out = NULL;
  463     int subtitle_out_max_size = 1024 * 1024;
  464     int subtitle_out_size, nb, i;
  465     AVCodecContext *enc;
  466     AVPacket pkt;
  467 
  468     if (pts == AV_NOPTS_VALUE) {
  469         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
  470         if (exit_on_error)
  471             exit_program(1);
  472         return;
  473     }
  474 
  475     enc = ost->enc_ctx;
  476 
  477     if (!subtitle_out) {
  478         subtitle_out = av_malloc(subtitle_out_max_size);
  479     }
  480 
  481     /* Note: DVB subtitle need one packet to draw them and one other
  482        packet to clear them */
  483     /* XXX: signal it in the codec context ? */
  484     if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
  485         nb = 2;
  486     else
  487         nb = 1;
  488 
  489     for (i = 0; i < nb; i++) {
  490         ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
  491         if (!check_recording_time(ost))
  492             return;
  493 
  494         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
  495         // start_display_time is required to be 0
  496         sub->pts               += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
  497         sub->end_display_time  -= sub->start_display_time;
  498         sub->start_display_time = 0;
  499 
  500         ost->frames_encoded++;
  501 
  502         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
  503                                                     subtitle_out_max_size, sub);
  504         if (subtitle_out_size < 0) {
  505             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
  506             exit_program(1);
  507         }
  508 
  509         av_init_packet(&pkt);
  510         pkt.data = subtitle_out;
  511         pkt.size = subtitle_out_size;
  512         pkt.pts  = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
  513         if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
  514             /* XXX: the pts correction is handled here. Maybe handling
  515                it in the codec would be better */
  516             if (i == 0)
  517                 pkt.pts += 90 * sub->start_display_time;
  518             else
  519                 pkt.pts += 90 * sub->end_display_time;
  520         }
  521         output_packet(of, &pkt, ost);
  522     }
  523 }
  524 
  525 static void do_video_out(OutputFile *of,
  526                          OutputStream *ost,
  527                          AVFrame *in_picture,
  528                          int *frame_size)
  529 {
  530     int ret, format_video_sync;
  531     AVPacket pkt;
  532     AVCodecContext *enc = ost->enc_ctx;
  533 
  534     *frame_size = 0;
  535 
  536     format_video_sync = video_sync_method;
  537     if (format_video_sync == VSYNC_AUTO)
  538         format_video_sync = (of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
  539                             (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
  540     if (format_video_sync != VSYNC_PASSTHROUGH &&
  541         ost->frame_number &&
  542         in_picture->pts != AV_NOPTS_VALUE &&
  543         in_picture->pts < ost->sync_opts) {
  544         nb_frames_drop++;
  545         av_log(NULL, AV_LOG_WARNING,
  546                "*** dropping frame %d from stream %d at ts %"PRId64"\n",
  547                ost->frame_number, ost->st->index, in_picture->pts);
  548         return;
  549     }
  550 
  551     if (in_picture->pts == AV_NOPTS_VALUE)
  552         in_picture->pts = ost->sync_opts;
  553     ost->sync_opts = in_picture->pts;
  554 
  555 
  556     if (!ost->frame_number)
  557         ost->first_pts = in_picture->pts;
  558 
  559     av_init_packet(&pkt);
  560     pkt.data = NULL;
  561     pkt.size = 0;
  562 
  563     if (ost->frame_number >= ost->max_frames)
  564         return;
  565 
  566     if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
  567         ost->top_field_first >= 0)
  568         in_picture->top_field_first = !!ost->top_field_first;
  569 
  570     in_picture->quality = enc->global_quality;
  571     in_picture->pict_type = 0;
  572     if (ost->forced_kf_index < ost->forced_kf_count &&
  573         in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
  574         in_picture->pict_type = AV_PICTURE_TYPE_I;
  575         ost->forced_kf_index++;
  576     }
  577 
  578     ost->frames_encoded++;
  579 
  580     ret = avcodec_send_frame(enc, in_picture);
  581     if (ret < 0)
  582         goto error;
  583 
  584     /*
  585      * For video, there may be reordering, so we can't throw away frames on
  586      * encoder flush, we need to limit them here, before they go into encoder.
  587      */
  588     ost->frame_number++;
  589 
  590     while (1) {
  591         ret = avcodec_receive_packet(enc, &pkt);
  592         if (ret == AVERROR(EAGAIN))
  593             break;
  594         if (ret < 0)
  595             goto error;
  596 
  597         output_packet(of, &pkt, ost);
  598         *frame_size = pkt.size;
  599 
  600         /* if two pass, output log */
  601         if (ost->logfile && enc->stats_out) {
  602             fprintf(ost->logfile, "%s", enc->stats_out);
  603         }
  604 
  605         ost->sync_opts++;
  606     }
  607 
  608     return;
  609 error:
  610     av_assert0(ret != AVERROR(EAGAIN) && ret != AVERROR_EOF);
  611     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
  612     exit_program(1);
  613 }
  614 
  615 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME
  616 static double psnr(double d)
  617 {
  618     return -10.0 * log(d) / log(10.0);
  619 }
  620 #endif
  621 
  622 static void do_video_stats(OutputStream *ost, int frame_size)
  623 {
  624     AVCodecContext *enc;
  625     int frame_number;
  626     double ti1, bitrate, avg_bitrate;
  627 
  628     /* this is executed just the first time do_video_stats is called */
  629     if (!vstats_file) {
  630         vstats_file = fopen(vstats_filename, "w");
  631         if (!vstats_file) {
  632             perror("fopen");
  633             exit_program(1);
  634         }
  635     }
  636 
  637     enc = ost->enc_ctx;
  638     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
  639         frame_number = ost->frame_number;
  640         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
  641                 ost->quality / (float)FF_QP2LAMBDA);
  642 
  643 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME
  644 FF_DISABLE_DEPRECATION_WARNINGS
  645         if (enc->flags & AV_CODEC_FLAG_PSNR)
  646             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
  647 FF_ENABLE_DEPRECATION_WARNINGS
  648 #endif
  649 
  650         fprintf(vstats_file,"f_size= %6d ", frame_size);
  651         /* compute pts value */
  652         ti1 = ost->sync_opts * av_q2d(enc->time_base);
  653         if (ti1 < 0.01)
  654             ti1 = 0.01;
  655 
  656         bitrate     = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
  657         avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
  658         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
  659                (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
  660 #if FF_API_CODED_FRAME
  661 FF_DISABLE_DEPRECATION_WARNINGS
  662         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
  663 FF_ENABLE_DEPRECATION_WARNINGS
  664 #endif
  665     }
  666 }
  667 
  668 static int init_output_stream(OutputStream *ost, char *error, int error_len);
  669 
  670 /*
  671  * Read one frame for lavfi output for ost and encode it.
  672  */
  673 static int poll_filter(OutputStream *ost)
  674 {
  675     OutputFile    *of = output_files[ost->file_index];
  676     AVFrame *filtered_frame = NULL;
  677     int frame_size, ret;
  678 
  679     if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
  680         return AVERROR(ENOMEM);
  681     }
  682     filtered_frame = ost->filtered_frame;
  683 
  684     if (!ost->initialized) {
  685         char error[1024];
  686         ret = init_output_stream(ost, error, sizeof(error));
  687         if (ret < 0) {
  688             av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
  689                    ost->file_index, ost->index, error);
  690             exit_program(1);
  691         }
  692     }
  693 
  694     if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
  695         !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
  696         ret = av_buffersink_get_samples(ost->filter->filter, filtered_frame,
  697                                          ost->enc_ctx->frame_size);
  698     else
  699         ret = av_buffersink_get_frame(ost->filter->filter, filtered_frame);
  700 
  701     if (ret < 0)
  702         return ret;
  703 
  704     if (filtered_frame->pts != AV_NOPTS_VALUE) {
  705         int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
  706         filtered_frame->pts = av_rescale_q(filtered_frame->pts,
  707                                            ost->filter->filter->inputs[0]->time_base,
  708                                            ost->enc_ctx->time_base) -
  709                               av_rescale_q(start_time,
  710                                            AV_TIME_BASE_Q,
  711                                            ost->enc_ctx->time_base);
  712     }
  713 
  714     switch (ost->filter->filter->inputs[0]->type) {
  715     case AVMEDIA_TYPE_VIDEO:
  716         if (!ost->frame_aspect_ratio)
  717             ost->enc_ctx->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
  718 
  719         do_video_out(of, ost, filtered_frame, &frame_size);
  720         if (vstats_filename && frame_size)
  721             do_video_stats(ost, frame_size);
  722         break;
  723     case AVMEDIA_TYPE_AUDIO:
  724         do_audio_out(of, ost, filtered_frame);
  725         break;
  726     default:
  727         // TODO support subtitle filters
  728         av_assert0(0);
  729     }
  730 
  731     av_frame_unref(filtered_frame);
  732 
  733     return 0;
  734 }
  735 
  736 static void finish_output_stream(OutputStream *ost)
  737 {
  738     OutputFile *of = output_files[ost->file_index];
  739     int i;
  740 
  741     ost->finished = 1;
  742 
  743     if (of->shortest) {
  744         for (i = 0; i < of->ctx->nb_streams; i++)
  745             output_streams[of->ost_index + i]->finished = 1;
  746     }
  747 }
  748 
  749 /*
  750  * Read as many frames from possible from lavfi and encode them.
  751  *
  752  * Always read from the active stream with the lowest timestamp. If no frames
  753  * are available for it then return EAGAIN and wait for more input. This way we
  754  * can use lavfi sources that generate unlimited amount of frames without memory
  755  * usage exploding.
  756  */
  757 static int poll_filters(void)
  758 {
  759     int i, ret = 0;
  760 
  761     while (ret >= 0 && !received_sigterm) {
  762         OutputStream *ost = NULL;
  763         int64_t min_pts = INT64_MAX;
  764 
  765         /* choose output stream with the lowest timestamp */
  766         for (i = 0; i < nb_output_streams; i++) {
  767             int64_t pts = output_streams[i]->sync_opts;
  768 
  769             if (output_streams[i]->filter && !output_streams[i]->filter->graph->graph &&
  770                 !output_streams[i]->filter->graph->nb_inputs) {
  771                 ret = configure_filtergraph(output_streams[i]->filter->graph);
  772                 if (ret < 0) {
  773                     av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
  774                     return ret;
  775                 }
  776             }
  777 
  778             if (!output_streams[i]->filter || output_streams[i]->finished ||
  779                 !output_streams[i]->filter->graph->graph)
  780                 continue;
  781 
  782             pts = av_rescale_q(pts, output_streams[i]->enc_ctx->time_base,
  783                                AV_TIME_BASE_Q);
  784             if (pts < min_pts) {
  785                 min_pts = pts;
  786                 ost = output_streams[i];
  787             }
  788         }
  789 
  790         if (!ost)
  791             break;
  792 
  793         ret = poll_filter(ost);
  794 
  795         if (ret == AVERROR_EOF) {
  796             finish_output_stream(ost);
  797             ret = 0;
  798         } else if (ret == AVERROR(EAGAIN))
  799             return 0;
  800     }
  801 
  802     return ret;
  803 }
  804 
  805 static void print_final_stats(int64_t total_size)
  806 {
  807     uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
  808     uint64_t data_size = 0;
  809     float percent = -1.0;
  810     int i, j;
  811 
  812     for (i = 0; i < nb_output_streams; i++) {
  813         OutputStream *ost = output_streams[i];
  814         switch (ost->enc_ctx->codec_type) {
  815             case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
  816             case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
  817             default:                 other_size += ost->data_size; break;
  818         }
  819         extra_size += ost->enc_ctx->extradata_size;
  820         data_size  += ost->data_size;
  821     }
  822 
  823     if (data_size && total_size >= data_size)
  824         percent = 100.0 * (total_size - data_size) / data_size;
  825 
  826     av_log(NULL, AV_LOG_INFO, "\n");
  827     av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
  828            video_size / 1024.0,
  829            audio_size / 1024.0,
  830            other_size / 1024.0,
  831            extra_size / 1024.0);
  832     if (percent >= 0.0)
  833         av_log(NULL, AV_LOG_INFO, "%f%%", percent);
  834     else
  835         av_log(NULL, AV_LOG_INFO, "unknown");
  836     av_log(NULL, AV_LOG_INFO, "\n");
  837 
  838     /* print verbose per-stream stats */
  839     for (i = 0; i < nb_input_files; i++) {
  840         InputFile *f = input_files[i];
  841         uint64_t total_packets = 0, total_size = 0;
  842 
  843         av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
  844                i, f->ctx->filename);
  845 
  846         for (j = 0; j < f->nb_streams; j++) {
  847             InputStream *ist = input_streams[f->ist_index + j];
  848             enum AVMediaType type = ist->dec_ctx->codec_type;
  849 
  850             total_size    += ist->data_size;
  851             total_packets += ist->nb_packets;
  852 
  853             av_log(NULL, AV_LOG_VERBOSE, "  Input stream #%d:%d (%s): ",
  854                    i, j, media_type_string(type));
  855             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
  856                    ist->nb_packets, ist->data_size);
  857 
  858             if (ist->decoding_needed) {
  859                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
  860                        ist->frames_decoded);
  861                 if (type == AVMEDIA_TYPE_AUDIO)
  862                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
  863                 av_log(NULL, AV_LOG_VERBOSE, "; ");
  864             }
  865 
  866             av_log(NULL, AV_LOG_VERBOSE, "\n");
  867         }
  868 
  869         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
  870                total_packets, total_size);
  871     }
  872 
  873     for (i = 0; i < nb_output_files; i++) {
  874         OutputFile *of = output_files[i];
  875         uint64_t total_packets = 0, total_size = 0;
  876 
  877         av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
  878                i, of->ctx->filename);
  879 
  880         for (j = 0; j < of->ctx->nb_streams; j++) {
  881             OutputStream *ost = output_streams[of->ost_index + j];
  882             enum AVMediaType type = ost->enc_ctx->codec_type;
  883 
  884             total_size    += ost->data_size;
  885             total_packets += ost->packets_written;
  886 
  887             av_log(NULL, AV_LOG_VERBOSE, "  Output stream #%d:%d (%s): ",
  888                    i, j, media_type_string(type));
  889             if (ost->encoding_needed) {
  890                 av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
  891                        ost->frames_encoded);
  892                 if (type == AVMEDIA_TYPE_AUDIO)
  893                     av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
  894                 av_log(NULL, AV_LOG_VERBOSE, "; ");
  895             }
  896 
  897             av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
  898                    ost->packets_written, ost->data_size);
  899 
  900             av_log(NULL, AV_LOG_VERBOSE, "\n");
  901         }
  902 
  903         av_log(NULL, AV_LOG_VERBOSE, "  Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
  904                total_packets, total_size);
  905     }
  906 }
  907 
  908 static void print_report(int is_last_report, int64_t timer_start)
  909 {
  910     char buf[1024];
  911     OutputStream *ost;
  912     AVFormatContext *oc;
  913     int64_t total_size;
  914     AVCodecContext *enc;
  915     int frame_number, vid, i;
  916     double bitrate, ti1, pts;
  917     static int64_t last_time = -1;
  918     static int qp_histogram[52];
  919 
  920     if (!print_stats && !is_last_report)
  921         return;
  922 
  923     if (!is_last_report) {
  924         int64_t cur_time;
  925         /* display the report every 0.5 seconds */
  926         cur_time = av_gettime_relative();
  927         if (last_time == -1) {
  928             last_time = cur_time;
  929             return;
  930         }
  931         if ((cur_time - last_time) < 500000)
  932             return;
  933         last_time = cur_time;
  934     }
  935 
  936 
  937     oc = output_files[0]->ctx;
  938 
  939     total_size = avio_size(oc->pb);
  940     if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
  941         total_size = avio_tell(oc->pb);
  942     if (total_size < 0) {
  943         char errbuf[128];
  944         av_strerror(total_size, errbuf, sizeof(errbuf));
  945         av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
  946                "avio_tell() failed: %s\n", errbuf);
  947         total_size = 0;
  948     }
  949 
  950     buf[0] = '\0';
  951     ti1 = 1e10;
  952     vid = 0;
  953     for (i = 0; i < nb_output_streams; i++) {
  954         float q = -1;
  955         ost = output_streams[i];
  956         enc = ost->enc_ctx;
  957         if (!ost->stream_copy)
  958             q = ost->quality / (float) FF_QP2LAMBDA;
  959 
  960         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
  961             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
  962         }
  963         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
  964             float t = (av_gettime_relative() - timer_start) / 1000000.0;
  965 
  966             frame_number = ost->frame_number;
  967             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
  968                      frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
  969             if (is_last_report)
  970                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
  971             if (qp_hist) {
  972                 int j;
  973                 int qp = lrintf(q);
  974                 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
  975                     qp_histogram[qp]++;
  976                 for (j = 0; j < 32; j++)
  977                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
  978             }
  979 
  980 #if FF_API_CODED_FRAME && FF_API_ERROR_FRAME
  981 FF_DISABLE_DEPRECATION_WARNINGS
  982             if (enc->flags & AV_CODEC_FLAG_PSNR) {
  983                 int j;
  984                 double error, error_sum = 0;
  985                 double scale, scale_sum = 0;
  986                 char type[3] = { 'Y','U','V' };
  987                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
  988                 for (j = 0; j < 3; j++) {
  989                     if (is_last_report) {
  990                         error = enc->error[j];
  991                         scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
  992                     } else {
  993                         error = enc->coded_frame->error[j];
  994                         scale = enc->width * enc->height * 255.0 * 255.0;
  995                     }
  996                     if (j)
  997                         scale /= 4;
  998                     error_sum += error;
  999                     scale_sum += scale;
 1000                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
 1001                 }
 1002                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
 1003             }
 1004 FF_ENABLE_DEPRECATION_WARNINGS
 1005 #endif
 1006             vid = 1;
 1007         }
 1008         /* compute min output value */
 1009         pts = (double)ost->last_mux_dts * av_q2d(ost->mux_timebase);
 1010         if ((pts < ti1) && (pts > 0))
 1011             ti1 = pts;
 1012     }
 1013     if (ti1 < 0.01)
 1014         ti1 = 0.01;
 1015 
 1016     bitrate = (double)(total_size * 8) / ti1 / 1000.0;
 1017 
 1018     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
 1019             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
 1020             (double)total_size / 1024, ti1, bitrate);
 1021 
 1022     if (nb_frames_drop)
 1023         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " drop=%d",
 1024                  nb_frames_drop);
 1025 
 1026     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
 1027 
 1028     fflush(stderr);
 1029 
 1030     if (is_last_report)
 1031         print_final_stats(total_size);
 1032 
 1033 }
 1034 
 1035 static void flush_encoders(void)
 1036 {
 1037     int i, ret;
 1038 
 1039     for (i = 0; i < nb_output_streams; i++) {
 1040         OutputStream   *ost = output_streams[i];
 1041         AVCodecContext *enc = ost->enc_ctx;
 1042         OutputFile      *of = output_files[ost->file_index];
 1043         int stop_encoding = 0;
 1044 
 1045         if (!ost->encoding_needed)
 1046             continue;
 1047 
 1048         if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
 1049             continue;
 1050 
 1051         if (enc->codec_type != AVMEDIA_TYPE_VIDEO && enc->codec_type != AVMEDIA_TYPE_AUDIO)
 1052             continue;
 1053 
 1054         avcodec_send_frame(enc, NULL);
 1055 
 1056         for (;;) {
 1057             const char *desc = NULL;
 1058 
 1059             switch (enc->codec_type) {
 1060             case AVMEDIA_TYPE_AUDIO:
 1061                 desc   = "Audio";
 1062                 break;
 1063             case AVMEDIA_TYPE_VIDEO:
 1064                 desc   = "Video";
 1065                 break;
 1066             default:
 1067                 av_assert0(0);
 1068             }
 1069 
 1070             if (1) {
 1071                 AVPacket pkt;
 1072                 av_init_packet(&pkt);
 1073                 pkt.data = NULL;
 1074                 pkt.size = 0;
 1075 
 1076                 ret = avcodec_receive_packet(enc, &pkt);
 1077                 if (ret < 0 && ret != AVERROR_EOF) {
 1078                     av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
 1079                     exit_program(1);
 1080                 }
 1081                 if (ost->logfile && enc->stats_out) {
 1082                     fprintf(ost->logfile, "%s", enc->stats_out);
 1083                 }
 1084                 if (ret == AVERROR_EOF) {
 1085                     stop_encoding = 1;
 1086                     break;
 1087                 }
 1088                 output_packet(of, &pkt, ost);
 1089             }
 1090 
 1091             if (stop_encoding)
 1092                 break;
 1093         }
 1094     }
 1095 }
 1096 
 1097 /*
 1098  * Check whether a packet from ist should be written into ost at this time
 1099  */
 1100 static int check_output_constraints(InputStream *ist, OutputStream *ost)
 1101 {
 1102     OutputFile *of = output_files[ost->file_index];
 1103     int ist_index  = input_files[ist->file_index]->ist_index + ist->st->index;
 1104 
 1105     if (ost->source_index != ist_index)
 1106         return 0;
 1107 
 1108     if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
 1109         return 0;
 1110 
 1111     return 1;
 1112 }
 1113 
 1114 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
 1115 {
 1116     OutputFile *of = output_files[ost->file_index];
 1117     InputFile   *f = input_files [ist->file_index];
 1118     int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
 1119     int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
 1120     AVPacket opkt;
 1121 
 1122     av_init_packet(&opkt);
 1123 
 1124     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
 1125         !ost->copy_initial_nonkeyframes)
 1126         return;
 1127 
 1128     if (of->recording_time != INT64_MAX &&
 1129         ist->last_dts >= of->recording_time + start_time) {
 1130         ost->finished = 1;
 1131         return;
 1132     }
 1133 
 1134     if (f->recording_time != INT64_MAX) {
 1135         start_time = f->ctx->start_time;
 1136         if (f->start_time != AV_NOPTS_VALUE)
 1137             start_time += f->start_time;
 1138         if (ist->last_dts >= f->recording_time + start_time) {
 1139             ost->finished = 1;
 1140             return;
 1141         }
 1142     }
 1143 
 1144     /* force the input stream PTS */
 1145     if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
 1146         ost->sync_opts++;
 1147 
 1148     if (pkt->pts != AV_NOPTS_VALUE)
 1149         opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
 1150     else
 1151         opkt.pts = AV_NOPTS_VALUE;
 1152 
 1153     if (pkt->dts == AV_NOPTS_VALUE)
 1154         opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->mux_timebase);
 1155     else
 1156         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
 1157     opkt.dts -= ost_tb_start_time;
 1158 
 1159     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
 1160     opkt.flags    = pkt->flags;
 1161 
 1162     // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
 1163     if (  ost->enc_ctx->codec_id != AV_CODEC_ID_H264
 1164        && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG1VIDEO
 1165        && ost->enc_ctx->codec_id != AV_CODEC_ID_MPEG2VIDEO
 1166        && ost->enc_ctx->codec_id != AV_CODEC_ID_VC1
 1167        ) {
 1168         if (av_parser_change(ost->parser, ost->parser_avctx,
 1169                              &opkt.data, &opkt.size,
 1170                              pkt->data, pkt->size,
 1171                              pkt->flags & AV_PKT_FLAG_KEY)) {
 1172             opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
 1173             if (!opkt.buf)
 1174                 exit_program(1);
 1175         }
 1176     } else {
 1177         opkt.data = pkt->data;
 1178         opkt.size = pkt->size;
 1179     }
 1180 
 1181     output_packet(of, &opkt, ost);
 1182 }
 1183 
 1184 static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
 1185 {
 1186     FilterGraph *fg = ifilter->graph;
 1187     int need_reinit, ret, i;
 1188 
 1189     /* determine if the parameters for this input changed */
 1190     need_reinit = ifilter->format != frame->format;
 1191     if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
 1192         (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
 1193         need_reinit = 1;
 1194 
 1195     switch (ifilter->ist->st->codecpar->codec_type) {
 1196     case AVMEDIA_TYPE_AUDIO:
 1197         need_reinit |= ifilter->sample_rate    != frame->sample_rate ||
 1198                        ifilter->channel_layout != frame->channel_layout;
 1199         break;
 1200     case AVMEDIA_TYPE_VIDEO:
 1201         need_reinit |= ifilter->width  != frame->width ||
 1202                        ifilter->height != frame->height;
 1203         break;
 1204     }
 1205 
 1206     if (need_reinit) {
 1207         ret = ifilter_parameters_from_frame(ifilter, frame);
 1208         if (ret < 0)
 1209             return ret;
 1210     }
 1211 
 1212     /* (re)init the graph if possible, otherwise buffer the frame and return */
 1213     if (need_reinit || !fg->graph) {
 1214         for (i = 0; i < fg->nb_inputs; i++) {
 1215             if (fg->inputs[i]->format < 0) {
 1216                 AVFrame *tmp = av_frame_clone(frame);
 1217                 if (!tmp)
 1218                     return AVERROR(ENOMEM);
 1219                 av_frame_unref(frame);
 1220 
 1221                 if (!av_fifo_space(ifilter->frame_queue)) {
 1222                     ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
 1223                     if (ret < 0)
 1224                         return ret;
 1225                 }
 1226                 av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
 1227                 return 0;
 1228             }
 1229         }
 1230 
 1231         ret = poll_filters();
 1232         if (ret < 0 && ret != AVERROR_EOF) {
 1233             char errbuf[128];
 1234             av_strerror(ret, errbuf, sizeof(errbuf));
 1235 
 1236             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
 1237             return ret;
 1238         }
 1239 
 1240         ret = configure_filtergraph(fg);
 1241         if (ret < 0) {
 1242             av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
 1243             return ret;
 1244         }
 1245     }
 1246 
 1247     ret = av_buffersrc_add_frame(ifilter->filter, frame);
 1248     if (ret < 0) {
 1249         av_log(NULL, AV_LOG_ERROR, "Error while filtering\n");
 1250         return ret;
 1251     }
 1252 
 1253     return 0;
 1254 }
 1255 
 1256 static int ifilter_send_eof(InputFilter *ifilter)
 1257 {
 1258     int i, j, ret;
 1259 
 1260     ifilter->eof = 1;
 1261 
 1262     if (ifilter->filter) {
 1263         ret = av_buffersrc_add_frame(ifilter->filter, NULL);
 1264         if (ret < 0)
 1265             return ret;
 1266     } else {
 1267         // the filtergraph was never configured
 1268         FilterGraph *fg = ifilter->graph;
 1269         for (i = 0; i < fg->nb_inputs; i++)
 1270             if (!fg->inputs[i]->eof)
 1271                 break;
 1272         if (i == fg->nb_inputs) {
 1273             // All the input streams have finished without the filtergraph
 1274             // ever being configured.
 1275             // Mark the output streams as finished.
 1276             for (j = 0; j < fg->nb_outputs; j++)
 1277                 finish_output_stream(fg->outputs[j]->ost);
 1278         }
 1279     }
 1280 
 1281     return 0;
 1282 }
 1283 
 1284 // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
 1285 // There is the following difference: if you got a frame, you must call
 1286 // it again with pkt=NULL. pkt==NULL is treated differently from pkt.size==0
 1287 // (pkt==NULL means get more output, pkt.size==0 is a flush/drain packet)
 1288 static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
 1289 {
 1290     int ret;
 1291 
 1292     *got_frame = 0;
 1293 
 1294     if (pkt) {
 1295         ret = avcodec_send_packet(avctx, pkt);
 1296         // In particular, we don't expect AVERROR(EAGAIN), because we read all
 1297         // decoded frames with avcodec_receive_frame() until done.
 1298         if (ret < 0)
 1299             return ret == AVERROR_EOF ? 0 : ret;
 1300     }
 1301 
 1302     ret = avcodec_receive_frame(avctx, frame);
 1303     if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
 1304         return ret;
 1305     if (ret >= 0)
 1306         *got_frame = 1;
 1307 
 1308     return 0;
 1309 }
 1310 
 1311 int guess_input_channel_layout(InputStream *ist)
 1312 {
 1313     AVCodecContext *dec = ist->dec_ctx;
 1314 
 1315     if (!dec->channel_layout) {
 1316         char layout_name[256];
 1317 
 1318         dec->channel_layout = av_get_default_channel_layout(dec->channels);
 1319         if (!dec->channel_layout)
 1320             return 0;
 1321         av_get_channel_layout_string(layout_name, sizeof(layout_name),
 1322                                      dec->channels, dec->channel_layout);
 1323         av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
 1324                "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
 1325     }
 1326     return 1;
 1327 }
 1328 
 1329 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
 1330                         int *decode_failed)
 1331 {
 1332     AVFrame *decoded_frame, *f;
 1333     AVCodecContext *avctx = ist->dec_ctx;
 1334     int i, ret, err = 0;
 1335 
 1336     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
 1337         return AVERROR(ENOMEM);
 1338     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
 1339         return AVERROR(ENOMEM);
 1340     decoded_frame = ist->decoded_frame;
 1341 
 1342     ret = decode(avctx, decoded_frame, got_output, pkt);
 1343     if (ret < 0)
 1344         *decode_failed = 1;
 1345     if (!*got_output || ret < 0)
 1346         return ret;
 1347 
 1348     ist->samples_decoded += decoded_frame->nb_samples;
 1349     ist->frames_decoded++;
 1350 
 1351     /* if the decoder provides a pts, use it instead of the last packet pts.
 1352        the decoder could be delaying output by a packet or more. */
 1353     if (decoded_frame->pts != AV_NOPTS_VALUE)
 1354         ist->next_dts = av_rescale_q(decoded_frame->pts, ist->st->time_base, AV_TIME_BASE_Q);
 1355     else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
 1356         decoded_frame->pts = pkt->pts;
 1357     }
 1358 
 1359     if (decoded_frame->pts != AV_NOPTS_VALUE)
 1360         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
 1361                                           ist->st->time_base,
 1362                                           (AVRational){1, avctx->sample_rate});
 1363     ist->nb_samples = decoded_frame->nb_samples;
 1364     for (i = 0; i < ist->nb_filters; i++) {
 1365         if (i < ist->nb_filters - 1) {
 1366             f = ist->filter_frame;
 1367             err = av_frame_ref(f, decoded_frame);
 1368             if (err < 0)
 1369                 break;
 1370         } else
 1371             f = decoded_frame;
 1372 
 1373         err = ifilter_send_frame(ist->filters[i], f);
 1374         if (err < 0)
 1375             break;
 1376     }
 1377 
 1378     av_frame_unref(ist->filter_frame);
 1379     av_frame_unref(decoded_frame);
 1380     return err < 0 ? err : ret;
 1381 }
 1382 
 1383 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output,
 1384                         int *decode_failed)
 1385 {
 1386     AVFrame *decoded_frame, *f;
 1387     int i, ret = 0, err = 0;
 1388 
 1389     if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
 1390         return AVERROR(ENOMEM);
 1391     if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
 1392         return AVERROR(ENOMEM);
 1393     decoded_frame = ist->decoded_frame;
 1394 
 1395     ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt);
 1396     if (ret < 0)
 1397         *decode_failed = 1;
 1398     if (!*got_output || ret < 0)
 1399         return ret;
 1400 
 1401     ist->frames_decoded++;
 1402 
 1403     if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
 1404         err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
 1405         if (err < 0)
 1406             goto fail;
 1407     }
 1408     ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
 1409 
 1410     decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pts,
 1411                                            decoded_frame->pkt_dts);
 1412     if (ist->framerate.num)
 1413         decoded_frame->pts = ist->cfr_next_pts++;
 1414 
 1415     if (ist->st->sample_aspect_ratio.num)
 1416         decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
 1417 
 1418     for (i = 0; i < ist->nb_filters; i++) {
 1419         if (i < ist->nb_filters - 1) {
 1420             f = ist->filter_frame;
 1421             err = av_frame_ref(f, decoded_frame);
 1422             if (err < 0)
 1423                 break;
 1424         } else
 1425             f = decoded_frame;
 1426 
 1427         err = ifilter_send_frame(ist->filters[i], f);
 1428         if (err < 0)
 1429             break;
 1430     }
 1431 
 1432 fail:
 1433     av_frame_unref(ist->filter_frame);
 1434     av_frame_unref(decoded_frame);
 1435     return err < 0 ? err : ret;
 1436 }
 1437 
 1438 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
 1439                                int *decode_failed)
 1440 {
 1441     AVSubtitle subtitle;
 1442     int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
 1443                                           &subtitle, got_output, pkt);
 1444     if (ret < 0) {
 1445         *decode_failed = 1;
 1446         return ret;
 1447     }
 1448     if (!*got_output)
 1449         return ret;
 1450 
 1451     ist->frames_decoded++;
 1452 
 1453     for (i = 0; i < nb_output_streams; i++) {
 1454         OutputStream *ost = output_streams[i];
 1455 
 1456         if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
 1457             continue;
 1458 
 1459         do_subtitle_out(output_files[ost->file_index], ost, ist, &subtitle, pkt->pts);
 1460     }
 1461 
 1462     avsubtitle_free(&subtitle);
 1463     return ret;
 1464 }
 1465 
 1466 static int send_filter_eof(InputStream *ist)
 1467 {
 1468     int i, ret;
 1469     for (i = 0; i < ist->nb_filters; i++) {
 1470         ret = ifilter_send_eof(ist->filters[i]);
 1471         if (ret < 0)
 1472             return ret;
 1473     }
 1474     return 0;
 1475 }
 1476 
 1477 /* pkt = NULL means EOF (needed to flush decoder buffers) */
 1478 static void process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
 1479 {
 1480     int i;
 1481     int repeating = 0;
 1482     AVPacket avpkt;
 1483 
 1484     if (ist->next_dts == AV_NOPTS_VALUE)
 1485         ist->next_dts = ist->last_dts;
 1486 
 1487     if (!pkt) {
 1488         /* EOF handling */
 1489         av_init_packet(&avpkt);
 1490         avpkt.data = NULL;
 1491         avpkt.size = 0;
 1492     } else {
 1493         avpkt = *pkt;
 1494     }
 1495 
 1496     if (pkt && pkt->dts != AV_NOPTS_VALUE)
 1497         ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
 1498 
 1499     // while we have more to decode or while the decoder did output something on EOF
 1500     while (ist->decoding_needed && (!pkt || avpkt.size > 0)) {
 1501         int ret = 0;
 1502         int got_output = 0;
 1503         int decode_failed = 0;
 1504 
 1505         if (!repeating)
 1506             ist->last_dts = ist->next_dts;
 1507 
 1508         switch (ist->dec_ctx->codec_type) {
 1509         case AVMEDIA_TYPE_AUDIO:
 1510             ret = decode_audio    (ist, repeating ? NULL : &avpkt, &got_output,
 1511                                    &decode_failed);
 1512             break;
 1513         case AVMEDIA_TYPE_VIDEO:
 1514             ret = decode_video    (ist, repeating ? NULL : &avpkt, &got_output,
 1515                                    &decode_failed);
 1516             if (repeating && !got_output)
 1517                 ;
 1518             else if (pkt && pkt->duration)
 1519                 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
 1520             else if (ist->st->avg_frame_rate.num)
 1521                 ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
 1522                                               AV_TIME_BASE_Q);
 1523             else if (ist->dec_ctx->framerate.num != 0) {
 1524                 int ticks      = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
 1525                                                    ist->dec_ctx->ticks_per_frame;
 1526                 ist->next_dts += av_rescale_q(ticks, ist->dec_ctx->framerate, AV_TIME_BASE_Q);
 1527             }
 1528             break;
 1529         case AVMEDIA_TYPE_SUBTITLE:
 1530             if (repeating)
 1531                 break;
 1532             ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
 1533             break;
 1534         default:
 1535             return;
 1536         }
 1537 
 1538         if (ret < 0) {
 1539             if (decode_failed) {
 1540                 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
 1541                        ist->file_index, ist->st->index);
 1542             } else {
 1543                 av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
 1544                        "data for stream #%d:%d\n", ist->file_index, ist->st->index);
 1545             }
 1546             if (!decode_failed || exit_on_error)
 1547                 exit_program(1);
 1548             break;
 1549         }
 1550 
 1551         if (!got_output)
 1552             break;
 1553 
 1554         repeating = 1;
 1555     }
 1556 
 1557     /* after flushing, send an EOF on all the filter inputs attached to the stream */
 1558     /* except when looping we need to flush but not to send an EOF */
 1559     if (!pkt && ist->decoding_needed && !no_eof) {
 1560         int ret = send_filter_eof(ist);
 1561         if (ret < 0) {
 1562             av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
 1563             exit_program(1);
 1564         }
 1565     }
 1566 
 1567     /* handle stream copy */
 1568     if (!ist->decoding_needed) {
 1569         ist->last_dts = ist->next_dts;
 1570         switch (ist->dec_ctx->codec_type) {
 1571         case AVMEDIA_TYPE_AUDIO:
 1572             ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
 1573                              ist->dec_ctx->sample_rate;
 1574             break;
 1575         case AVMEDIA_TYPE_VIDEO:
 1576             if (ist->dec_ctx->framerate.num != 0) {
 1577                 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
 1578                 ist->next_dts += ((int64_t)AV_TIME_BASE *
 1579                                   ist->dec_ctx->framerate.den * ticks) /
 1580                                   ist->dec_ctx->framerate.num;
 1581             }
 1582             break;
 1583         }
 1584     }
 1585     for (i = 0; pkt && i < nb_output_streams; i++) {
 1586         OutputStream *ost = output_streams[i];
 1587 
 1588         if (!check_output_constraints(ist, ost) || ost->encoding_needed)
 1589             continue;
 1590 
 1591         do_streamcopy(ist, ost, pkt);
 1592     }
 1593 
 1594     return;
 1595 }
 1596 
 1597 static void print_sdp(void)
 1598 {
 1599     char sdp[16384];
 1600     int i;
 1601     AVFormatContext **avc;
 1602 
 1603     for (i = 0; i < nb_output_files; i++) {
 1604         if (!output_files[i]->header_written)
 1605             return;
 1606     }
 1607 
 1608     avc = av_malloc(sizeof(*avc) * nb_output_files);
 1609     if (!avc)
 1610         exit_program(1);
 1611     for (i = 0; i < nb_output_files; i++)
 1612         avc[i] = output_files[i]->ctx;
 1613 
 1614     av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
 1615     printf("SDP:\n%s\n", sdp);
 1616     fflush(stdout);
 1617     av_freep(&avc);
 1618 }
 1619 
 1620 static const HWAccel *get_hwaccel(enum AVPixelFormat pix_fmt)
 1621 {
 1622     int i;
 1623     for (i = 0; hwaccels[i].name; i++)
 1624         if (hwaccels[i].pix_fmt == pix_fmt)
 1625             return &hwaccels[i];
 1626     return NULL;
 1627 }
 1628 
 1629 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
 1630 {
 1631     InputStream *ist = s->opaque;
 1632     const enum AVPixelFormat *p;
 1633     int ret;
 1634 
 1635     for (p = pix_fmts; *p != -1; p++) {
 1636         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
 1637         const HWAccel *hwaccel;
 1638 
 1639         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
 1640             break;
 1641 
 1642         hwaccel = get_hwaccel(*p);
 1643         if (!hwaccel ||
 1644             (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
 1645             (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
 1646             continue;
 1647 
 1648         ret = hwaccel->init(s);
 1649         if (ret < 0) {
 1650             if (ist->hwaccel_id == hwaccel->id) {
 1651                 av_log(NULL, AV_LOG_FATAL,
 1652                        "%s hwaccel requested for input stream #%d:%d, "
 1653                        "but cannot be initialized.\n", hwaccel->name,
 1654                        ist->file_index, ist->st->index);
 1655                 return AV_PIX_FMT_NONE;
 1656             }
 1657             continue;
 1658         }
 1659 
 1660         if (ist->hw_frames_ctx) {
 1661             s->hw_frames_ctx = av_buffer_ref(ist->hw_frames_ctx);
 1662             if (!s->hw_frames_ctx)
 1663                 return AV_PIX_FMT_NONE;
 1664         }
 1665 
 1666         ist->active_hwaccel_id = hwaccel->id;
 1667         ist->hwaccel_pix_fmt   = *p;
 1668         break;
 1669     }
 1670 
 1671     return *p;
 1672 }
 1673 
 1674 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
 1675 {
 1676     InputStream *ist = s->opaque;
 1677 
 1678     if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
 1679         return ist->hwaccel_get_buffer(s, frame, flags);
 1680 
 1681     return avcodec_default_get_buffer2(s, frame, flags);
 1682 }
 1683 
 1684 static int init_input_stream(int ist_index, char *error, int error_len)
 1685 {
 1686     int ret;
 1687     InputStream *ist = input_streams[ist_index];
 1688 
 1689     if (ist->decoding_needed) {
 1690         AVCodec *codec = ist->dec;
 1691         if (!codec) {
 1692             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
 1693                     ist->dec_ctx->codec_id, ist->file_index, ist->st->index);
 1694             return AVERROR(EINVAL);
 1695         }
 1696 
 1697         ist->dec_ctx->opaque                = ist;
 1698         ist->dec_ctx->get_format            = get_format;
 1699         ist->dec_ctx->get_buffer2           = get_buffer;
 1700         ist->dec_ctx->thread_safe_callbacks = 1;
 1701 
 1702         av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
 1703 
 1704         if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
 1705             av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
 1706         if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
 1707             char errbuf[128];
 1708             if (ret == AVERROR_EXPERIMENTAL)
 1709                 abort_codec_experimental(codec, 0);
 1710 
 1711             av_strerror(ret, errbuf, sizeof(errbuf));
 1712 
 1713             snprintf(error, error_len,
 1714                      "Error while opening decoder for input stream "
 1715                      "#%d:%d : %s",
 1716                      ist->file_index, ist->st->index, errbuf);
 1717             return ret;
 1718         }
 1719         assert_avoptions(ist->decoder_opts);
 1720     }
 1721 
 1722     ist->last_dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
 1723     ist->next_dts = AV_NOPTS_VALUE;
 1724     init_pts_correction(&ist->pts_ctx);
 1725 
 1726     return 0;
 1727 }
 1728 
 1729 static InputStream *get_input_stream(OutputStream *ost)
 1730 {
 1731     if (ost->source_index >= 0)
 1732         return input_streams[ost->source_index];
 1733 
 1734     if (ost->filter) {
 1735         FilterGraph *fg = ost->filter->graph;
 1736         int i;
 1737 
 1738         for (i = 0; i < fg->nb_inputs; i++)
 1739             if (fg->inputs[i]->ist->dec_ctx->codec_type == ost->enc_ctx->codec_type)
 1740                 return fg->inputs[i]->ist;
 1741     }
 1742 
 1743     return NULL;
 1744 }
 1745 
 1746 /* open the muxer when all the streams are initialized */
 1747 static int check_init_output_file(OutputFile *of, int file_index)
 1748 {
 1749     int ret, i;
 1750 
 1751     for (i = 0; i < of->ctx->nb_streams; i++) {
 1752         OutputStream *ost = output_streams[of->ost_index + i];
 1753         if (!ost->initialized)
 1754             return 0;
 1755     }
 1756 
 1757     of->ctx->interrupt_callback = int_cb;
 1758 
 1759     ret = avformat_write_header(of->ctx, &of->opts);
 1760     if (ret < 0) {
 1761         char errbuf[128];
 1762 
 1763         av_strerror(ret, errbuf, sizeof(errbuf));
 1764 
 1765         av_log(NULL, AV_LOG_ERROR,
 1766                "Could not write header for output file #%d "
 1767                "(incorrect codec parameters ?): %s",
 1768                file_index, errbuf);
 1769         return ret;
 1770     }
 1771     assert_avoptions(of->opts);
 1772     of->header_written = 1;
 1773 
 1774     av_dump_format(of->ctx, file_index, of->ctx->filename, 1);
 1775 
 1776     if (want_sdp)
 1777         print_sdp();
 1778 
 1779     /* flush the muxing queues */
 1780     for (i = 0; i < of->ctx->nb_streams; i++) {
 1781         OutputStream *ost = output_streams[of->ost_index + i];
 1782 
 1783         while (av_fifo_size(ost->muxing_queue)) {
 1784             AVPacket pkt;
 1785             av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
 1786             write_packet(of, &pkt, ost);
 1787         }
 1788     }
 1789 
 1790     return 0;
 1791 }
 1792 
 1793 static int init_output_bsfs(OutputStream *ost)
 1794 {
 1795     AVBSFContext *ctx;
 1796     int i, ret;
 1797 
 1798     if (!ost->nb_bitstream_filters)
 1799         return 0;
 1800 
 1801     ost->bsf_ctx = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_ctx));
 1802     if (!ost->bsf_ctx)
 1803         return AVERROR(ENOMEM);
 1804 
 1805     for (i = 0; i < ost->nb_bitstream_filters; i++) {
 1806         ret = av_bsf_alloc(ost->bitstream_filters[i], &ctx);
 1807         if (ret < 0) {
 1808             av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
 1809             return ret;
 1810         }
 1811         ost->bsf_ctx[i] = ctx;
 1812 
 1813         ret = avcodec_parameters_copy(ctx->par_in,
 1814                                       i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
 1815         if (ret < 0)
 1816             return ret;
 1817 
 1818         ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
 1819 
 1820         ret = av_bsf_init(ctx);
 1821         if (ret < 0) {
 1822             av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
 1823                    ost->bitstream_filters[i]->name);
 1824             return ret;
 1825         }
 1826     }
 1827 
 1828     ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
 1829     ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
 1830     if (ret < 0)
 1831         return ret;
 1832 
 1833     ost->st->time_base = ctx->time_base_out;
 1834 
 1835     return 0;
 1836 }
 1837 
 1838 static int init_output_stream_streamcopy(OutputStream *ost)
 1839 {
 1840     OutputFile *of = output_files[ost->file_index];
 1841     InputStream *ist = get_input_stream(ost);
 1842     AVCodecParameters *par_dst = ost->st->codecpar;
 1843     AVCodecParameters *par_src = ist->st->codecpar;
 1844     AVRational sar;
 1845     uint32_t codec_tag = par_dst->codec_tag;
 1846     int i, ret;
 1847 
 1848     if (!codec_tag) {
 1849         if (!of->ctx->oformat->codec_tag ||
 1850              av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
 1851              av_codec_get_tag(of->ctx->oformat->codec_tag, par_src->codec_id) <= 0)
 1852             codec_tag = par_src->codec_tag;
 1853     }
 1854 
 1855     ret = avcodec_parameters_copy(par_dst, par_src);
 1856     if (ret < 0)
 1857         return ret;
 1858 
 1859     par_dst->codec_tag = codec_tag;
 1860 
 1861     ost->st->disposition = ist->st->disposition;
 1862 
 1863     ost->st->time_base = ist->st->time_base;
 1864 
 1865     if (ist->st->nb_side_data) {
 1866         ost->st->side_data = av_realloc_array(NULL, ist->st->nb_side_data,
 1867                                               sizeof(*ist->st->side_data));
 1868         if (!ost->st->side_data)
 1869             return AVERROR(ENOMEM);
 1870 
 1871         for (i = 0; i < ist->st->nb_side_data; i++) {
 1872             const AVPacketSideData *sd_src = &ist->st->side_data[i];
 1873             AVPacketSideData *sd_dst = &ost->st->side_data[i];
 1874 
 1875             sd_dst->data = av_malloc(sd_src->size);
 1876             if (!sd_dst->data)
 1877                 return AVERROR(ENOMEM);
 1878             memcpy(sd_dst->data, sd_src->data, sd_src->size);
 1879             sd_dst->size = sd_src->size;
 1880             sd_dst->type = sd_src->type;
 1881             ost->st->nb_side_data++;
 1882         }
 1883     }
 1884 
 1885     ost->parser = av_parser_init(par_dst->codec_id);
 1886     ost->parser_avctx = avcodec_alloc_context3(NULL);
 1887     if (!ost->parser_avctx)
 1888         return AVERROR(ENOMEM);
 1889 
 1890     if (par_dst->codec_type == AVMEDIA_TYPE_VIDEO) {
 1891         if (ost->frame_aspect_ratio)
 1892             sar = av_d2q(ost->frame_aspect_ratio * par_dst->height / par_dst->width, 255);
 1893         else if (ist->st->sample_aspect_ratio.num)
 1894             sar = ist->st->sample_aspect_ratio;
 1895         else
 1896             sar = par_src->sample_aspect_ratio;
 1897         ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
 1898     }
 1899 
 1900     return 0;
 1901 }
 1902 
 1903 static void set_encoder_id(OutputFile *of, OutputStream *ost)
 1904 {
 1905     AVDictionaryEntry *e;
 1906 
 1907     uint8_t *encoder_string;
 1908     int encoder_string_len;
 1909     int format_flags = 0;
 1910 
 1911     e = av_dict_get(of->opts, "fflags", NULL, 0);
 1912     if (e) {
 1913         const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
 1914         if (!o)
 1915             return;
 1916         av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
 1917     }
 1918 
 1919     encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
 1920     encoder_string     = av_mallocz(encoder_string_len);
 1921     if (!encoder_string)
 1922         exit_program(1);
 1923 
 1924     if (!(format_flags & AVFMT_FLAG_BITEXACT))
 1925         av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
 1926     av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
 1927     av_dict_set(&ost->st->metadata, "encoder",  encoder_string,
 1928                 AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
 1929 }
 1930 
 1931 static void parse_forced_key_frames(char *kf, OutputStream *ost,
 1932                                     AVCodecContext *avctx)
 1933 {
 1934     char *p;
 1935     int n = 1, i;
 1936     int64_t t;
 1937 
 1938     for (p = kf; *p; p++)
 1939         if (*p == ',')
 1940             n++;
 1941     ost->forced_kf_count = n;
 1942     ost->forced_kf_pts   = av_malloc(sizeof(*ost->forced_kf_pts) * n);
 1943     if (!ost->forced_kf_pts) {
 1944         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
 1945         exit_program(1);
 1946     }
 1947 
 1948     p = kf;
 1949     for (i = 0; i < n; i++) {
 1950         char *next = strchr(p, ',');
 1951 
 1952         if (next)
 1953             *next++ = 0;
 1954 
 1955         t = parse_time_or_die("force_key_frames", p, 1);
 1956         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
 1957 
 1958         p = next;
 1959     }
 1960 }
 1961 
 1962 static int init_output_stream_encode(OutputStream *ost)
 1963 {
 1964     InputStream *ist = get_input_stream(ost);
 1965     AVCodecContext *enc_ctx = ost->enc_ctx;
 1966     AVCodecContext *dec_ctx = NULL;
 1967 
 1968     set_encoder_id(output_files[ost->file_index], ost);
 1969 
 1970     if (ist) {
 1971         ost->st->disposition = ist->st->disposition;
 1972 
 1973         dec_ctx = ist->dec_ctx;
 1974 
 1975         enc_ctx->bits_per_raw_sample    = dec_ctx->bits_per_raw_sample;
 1976         enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
 1977     }
 1978 
 1979     switch (enc_ctx->codec_type) {
 1980     case AVMEDIA_TYPE_AUDIO:
 1981         enc_ctx->sample_fmt     = ost->filter->filter->inputs[0]->format;
 1982         enc_ctx->sample_rate    = ost->filter->filter->inputs[0]->sample_rate;
 1983         enc_ctx->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
 1984         enc_ctx->channels       = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
 1985         enc_ctx->time_base      = (AVRational){ 1, enc_ctx->sample_rate };
 1986         break;
 1987     case AVMEDIA_TYPE_VIDEO:
 1988         enc_ctx->time_base = ost->filter->filter->inputs[0]->time_base;
 1989 
 1990         enc_ctx->width  = ost->filter->filter->inputs[0]->w;
 1991         enc_ctx->height = ost->filter->filter->inputs[0]->h;
 1992         enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 1993             ost->frame_aspect_ratio ? // overridden by the -aspect cli option
 1994             av_d2q(ost->frame_aspect_ratio * enc_ctx->height/enc_ctx->width, 255) :
 1995             ost->filter->filter->inputs[0]->sample_aspect_ratio;
 1996         enc_ctx->pix_fmt = ost->filter->filter->inputs[0]->format;
 1997 
 1998         ost->st->avg_frame_rate = ost->frame_rate;
 1999 
 2000         if (dec_ctx &&
 2001             (enc_ctx->width   != dec_ctx->width  ||
 2002              enc_ctx->height  != dec_ctx->height ||
 2003              enc_ctx->pix_fmt != dec_ctx->pix_fmt)) {
 2004             enc_ctx->bits_per_raw_sample = 0;
 2005         }
 2006 
 2007         if (ost->forced_keyframes)
 2008             parse_forced_key_frames(ost->forced_keyframes, ost,
 2009                                     ost->enc_ctx);
 2010         break;
 2011     case AVMEDIA_TYPE_SUBTITLE:
 2012         enc_ctx->time_base = (AVRational){1, 1000};
 2013         break;
 2014     default:
 2015         abort();
 2016         break;
 2017     }
 2018 
 2019     return 0;
 2020 }
 2021 
 2022 static int init_output_stream(OutputStream *ost, char *error, int error_len)
 2023 {
 2024     int ret = 0;
 2025 
 2026     if (ost->encoding_needed) {
 2027         AVCodec      *codec = ost->enc;
 2028         AVCodecContext *dec = NULL;
 2029         InputStream *ist;
 2030 
 2031         ret = init_output_stream_encode(ost);
 2032         if (ret < 0)
 2033             return ret;
 2034 
 2035         if ((ist = get_input_stream(ost)))
 2036             dec = ist->dec_ctx;
 2037         if (dec && dec->subtitle_header) {
 2038             ost->enc_ctx->subtitle_header = av_malloc(dec->subtitle_header_size);
 2039             if (!ost->enc_ctx->subtitle_header)
 2040                 return AVERROR(ENOMEM);
 2041             memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
 2042             ost->enc_ctx->subtitle_header_size = dec->subtitle_header_size;
 2043         }
 2044         if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
 2045             av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
 2046 
 2047         if (ost->filter && ost->filter->filter->inputs[0]->hw_frames_ctx) {
 2048             ost->enc_ctx->hw_frames_ctx = av_buffer_ref(ost->filter->filter->inputs[0]->hw_frames_ctx);
 2049             if (!ost->enc_ctx->hw_frames_ctx)
 2050                 return AVERROR(ENOMEM);
 2051         }
 2052 
 2053         if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
 2054             if (ret == AVERROR_EXPERIMENTAL)
 2055                 abort_codec_experimental(codec, 1);
 2056             snprintf(error, error_len,
 2057                      "Error while opening encoder for output stream #%d:%d - "
 2058                      "maybe incorrect parameters such as bit_rate, rate, width or height",
 2059                     ost->file_index, ost->index);
 2060             return ret;
 2061         }
 2062         assert_avoptions(ost->encoder_opts);
 2063         if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000)
 2064             av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
 2065                                          "It takes bits/s as argument, not kbits/s\n");
 2066 
 2067         ret = avcodec_parameters_from_context(ost->st->codecpar, ost->enc_ctx);
 2068         if (ret < 0) {
 2069             av_log(NULL, AV_LOG_FATAL,
 2070                    "Error initializing the output stream codec context.\n");
 2071             exit_program(1);
 2072         }
 2073 
 2074         if (ost->enc_ctx->nb_coded_side_data) {
 2075             int i;
 2076 
 2077             ost->st->side_data = av_realloc_array(NULL, ost->enc_ctx->nb_coded_side_data,
 2078                                                   sizeof(*ost->st->side_data));
 2079             if (!ost->st->side_data)
 2080                 return AVERROR(ENOMEM);
 2081 
 2082             for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
 2083                 const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
 2084                 AVPacketSideData *sd_dst = &ost->st->side_data[i];
 2085 
 2086                 sd_dst->data = av_malloc(sd_src->size);
 2087                 if (!sd_dst->data)
 2088                     return AVERROR(ENOMEM);
 2089                 memcpy(sd_dst->data, sd_src->data, sd_src->size);
 2090                 sd_dst->size = sd_src->size;
 2091                 sd_dst->type = sd_src->type;
 2092                 ost->st->nb_side_data++;
 2093             }
 2094         }
 2095 
 2096         ost->st->time_base = ost->enc_ctx->time_base;
 2097     } else if (ost->stream_copy) {
 2098         ret = init_output_stream_streamcopy(ost);
 2099         if (ret < 0)
 2100             return ret;
 2101 
 2102         /*
 2103          * FIXME: will the codec context used by the parser during streamcopy
 2104          * This should go away with the new parser API.
 2105          */
 2106         ret = avcodec_parameters_to_context(ost->parser_avctx, ost->st->codecpar);
 2107         if (ret < 0)
 2108             return ret;
 2109     }
 2110 
 2111     /* initialize bitstream filters for the output stream
 2112      * needs to be done here, because the codec id for streamcopy is not
 2113      * known until now */
 2114     ret = init_output_bsfs(ost);
 2115     if (ret < 0)
 2116         return ret;
 2117 
 2118     ost->mux_timebase = ost->st->time_base;
 2119 
 2120     ost->initialized = 1;
 2121 
 2122     ret = check_init_output_file(output_files[ost->file_index], ost->file_index);
 2123     if (ret < 0)
 2124         return ret;
 2125 
 2126     return ret;
 2127 }
 2128 
 2129 static int transcode_init(void)
 2130 {
 2131     int ret = 0, i, j, k;
 2132     OutputStream *ost;
 2133     InputStream *ist;
 2134     char error[1024];
 2135 
 2136     /* init framerate emulation */
 2137     for (i = 0; i < nb_input_files; i++) {
 2138         InputFile *ifile = input_files[i];
 2139         if (ifile->rate_emu)
 2140             for (j = 0; j < ifile->nb_streams; j++)
 2141                 input_streams[j + ifile->ist_index]->start = av_gettime_relative();
 2142     }
 2143 
 2144     /* init input streams */
 2145     for (i = 0; i < nb_input_streams; i++)
 2146         if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
 2147             goto dump_format;
 2148 
 2149     /* open each encoder */
 2150     for (i = 0; i < nb_output_streams; i++) {
 2151         // skip streams fed from filtergraphs until we have a frame for them
 2152         if (output_streams[i]->filter)
 2153             continue;
 2154 
 2155         ret = init_output_stream(output_streams[i], error, sizeof(error));
 2156         if (ret < 0)
 2157             goto dump_format;
 2158     }
 2159 
 2160 
 2161     /* discard unused programs */
 2162     for (i = 0; i < nb_input_files; i++) {
 2163         InputFile *ifile = input_files[i];
 2164         for (j = 0; j < ifile->ctx->nb_programs; j++) {
 2165             AVProgram *p = ifile->ctx->programs[j];
 2166             int discard  = AVDISCARD_ALL;
 2167 
 2168             for (k = 0; k < p->nb_stream_indexes; k++)
 2169                 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
 2170                     discard = AVDISCARD_DEFAULT;
 2171                     break;
 2172                 }
 2173             p->discard = discard;
 2174         }
 2175     }
 2176 
 2177  dump_format:
 2178     /* dump the stream mapping */
 2179     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
 2180     for (i = 0; i < nb_input_streams; i++) {
 2181         ist = input_streams[i];
 2182 
 2183         for (j = 0; j < ist->nb_filters; j++) {
 2184             if (!filtergraph_is_simple(ist->filters[j]->graph)) {
 2185                 av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d (%s) -> %s",
 2186                        ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
 2187                        ist->filters[j]->name);
 2188                 if (nb_filtergraphs > 1)
 2189                     av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
 2190                 av_log(NULL, AV_LOG_INFO, "\n");
 2191             }
 2192         }
 2193     }
 2194 
 2195     for (i = 0; i < nb_output_streams; i++) {
 2196         ost = output_streams[i];
 2197 
 2198         if (ost->attachment_filename) {
 2199             /* an attached file */
 2200             av_log(NULL, AV_LOG_INFO, "  File %s -> Stream #%d:%d\n",
 2201                    ost->attachment_filename, ost->file_index, ost->index);
 2202             continue;
 2203         }
 2204 
 2205         if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
 2206             /* output from a complex graph */
 2207             av_log(NULL, AV_LOG_INFO, "  %s", ost->filter->name);
 2208             if (nb_filtergraphs > 1)
 2209                 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
 2210 
 2211             av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
 2212                    ost->index, ost->enc ? ost->enc->name : "?");
 2213             continue;
 2214         }
 2215 
 2216         av_log(NULL, AV_LOG_INFO, "  Stream #%d:%d -> #%d:%d",
 2217                input_streams[ost->source_index]->file_index,
 2218                input_streams[ost->source_index]->st->index,
 2219                ost->file_index,
 2220                ost->index);
 2221         if (ost->sync_ist != input_streams[ost->source_index])
 2222             av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
 2223                    ost->sync_ist->file_index,
 2224                    ost->sync_ist->st->index);
 2225         if (ost->stream_copy)
 2226             av_log(NULL, AV_LOG_INFO, " (copy)");
 2227         else {
 2228             const AVCodec *in_codec    = input_streams[ost->source_index]->dec;
 2229             const AVCodec *out_codec   = ost->enc;
 2230             const char *decoder_name   = "?";
 2231             const char *in_codec_name  = "?";
 2232             const char *encoder_name   = "?";
 2233             const char *out_codec_name = "?";
 2234             const AVCodecDescriptor *desc;
 2235 
 2236             if (in_codec) {
 2237                 decoder_name  = in_codec->name;
 2238                 desc = avcodec_descriptor_get(in_codec->id);
 2239                 if (desc)
 2240                     in_codec_name = desc->name;
 2241                 if (!strcmp(decoder_name, in_codec_name))
 2242                     decoder_name = "native";
 2243             }
 2244 
 2245             if (out_codec) {
 2246                 encoder_name   = out_codec->name;
 2247                 desc = avcodec_descriptor_get(out_codec->id);
 2248                 if (desc)
 2249                     out_codec_name = desc->name;
 2250                 if (!strcmp(encoder_name, out_codec_name))
 2251                     encoder_name = "native";
 2252             }
 2253 
 2254             av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
 2255                    in_codec_name, decoder_name,
 2256                    out_codec_name, encoder_name);
 2257         }
 2258         av_log(NULL, AV_LOG_INFO, "\n");
 2259     }
 2260 
 2261     if (ret) {
 2262         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
 2263         return ret;
 2264     }
 2265 
 2266     return 0;
 2267 }
 2268 
 2269 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
 2270 static int need_output(void)
 2271 {
 2272     int i;
 2273 
 2274     for (i = 0; i < nb_output_streams; i++) {
 2275         OutputStream *ost    = output_streams[i];
 2276         OutputFile *of       = output_files[ost->file_index];
 2277         AVFormatContext *os  = output_files[ost->file_index]->ctx;
 2278 
 2279         if (ost->finished ||
 2280             (os->pb && avio_tell(os->pb) >= of->limit_filesize))
 2281             continue;
 2282         if (ost->frame_number >= ost->max_frames) {
 2283             int j;
 2284             for (j = 0; j < of->ctx->nb_streams; j++)
 2285                 output_streams[of->ost_index + j]->finished = 1;
 2286             continue;
 2287         }
 2288 
 2289         return 1;
 2290     }
 2291 
 2292     return 0;
 2293 }
 2294 
 2295 static InputFile *select_input_file(void)
 2296 {
 2297     InputFile *ifile = NULL;
 2298     int64_t ipts_min = INT64_MAX;
 2299     int i;
 2300 
 2301     for (i = 0; i < nb_input_streams; i++) {
 2302         InputStream *ist = input_streams[i];
 2303         int64_t ipts     = ist->last_dts;
 2304 
 2305         if (ist->discard || input_files[ist->file_index]->eagain)
 2306             continue;
 2307         if (!input_files[ist->file_index]->eof_reached) {
 2308             if (ipts < ipts_min) {
 2309                 ipts_min = ipts;
 2310                 ifile    = input_files[ist->file_index];
 2311             }
 2312         }
 2313     }
 2314 
 2315     return ifile;
 2316 }
 2317 
 2318 #if HAVE_PTHREADS
 2319 static void *input_thread(void *arg)
 2320 {
 2321     InputFile *f = arg;
 2322     int ret = 0;
 2323 
 2324     while (!transcoding_finished && ret >= 0) {
 2325         AVPacket pkt;
 2326         ret = av_read_frame(f->ctx, &pkt);
 2327 
 2328         if (ret == AVERROR(EAGAIN)) {
 2329             av_usleep(10000);
 2330             ret = 0;
 2331             continue;
 2332         } else if (ret < 0)
 2333             break;
 2334 
 2335         pthread_mutex_lock(&f->fifo_lock);
 2336         while (!av_fifo_space(f->fifo))
 2337             pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
 2338 
 2339         av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
 2340 
 2341         pthread_mutex_unlock(&f->fifo_lock);
 2342     }
 2343 
 2344     f->finished = 1;
 2345     return NULL;
 2346 }
 2347 
 2348 static void free_input_threads(void)
 2349 {
 2350     int i;
 2351 
 2352     if (nb_input_files == 1)
 2353         return;
 2354 
 2355     transcoding_finished = 1;
 2356 
 2357     for (i = 0; i < nb_input_files; i++) {
 2358         InputFile *f = input_files[i];
 2359         AVPacket pkt;
 2360 
 2361         if (!f->fifo || f->joined)
 2362             continue;
 2363 
 2364         pthread_mutex_lock(&f->fifo_lock);
 2365         while (av_fifo_size(f->fifo)) {
 2366             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
 2367             av_packet_unref(&pkt);
 2368         }
 2369         pthread_cond_signal(&f->fifo_cond);
 2370         pthread_mutex_unlock(&f->fifo_lock);
 2371 
 2372         pthread_join(f->thread, NULL);
 2373         f->joined = 1;
 2374 
 2375         while (av_fifo_size(f->fifo)) {
 2376             av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
 2377             av_packet_unref(&pkt);
 2378         }
 2379         av_fifo_free(f->fifo);
 2380     }
 2381 }
 2382 
 2383 static int init_input_threads(void)
 2384 {
 2385     int i, ret;
 2386 
 2387     if (nb_input_files == 1)
 2388         return 0;
 2389 
 2390     for (i = 0; i < nb_input_files; i++) {
 2391         InputFile *f = input_files[i];
 2392 
 2393         if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
 2394             return AVERROR(ENOMEM);
 2395 
 2396         pthread_mutex_init(&f->fifo_lock, NULL);
 2397         pthread_cond_init (&f->fifo_cond, NULL);
 2398 
 2399         if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
 2400             return AVERROR(ret);
 2401     }
 2402     return 0;
 2403 }
 2404 
 2405 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
 2406 {
 2407     int ret = 0;
 2408 
 2409     pthread_mutex_lock(&f->fifo_lock);
 2410 
 2411     if (av_fifo_size(f->fifo)) {
 2412         av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
 2413         pthread_cond_signal(&f->fifo_cond);
 2414     } else {
 2415         if (f->finished)
 2416             ret = AVERROR_EOF;
 2417         else
 2418             ret = AVERROR(EAGAIN);
 2419     }
 2420 
 2421     pthread_mutex_unlock(&f->fifo_lock);
 2422 
 2423     return ret;
 2424 }
 2425 #endif
 2426 
 2427 static int get_input_packet(InputFile *f, AVPacket *pkt)
 2428 {
 2429     if (f->rate_emu) {
 2430         int i;
 2431         for (i = 0; i < f->nb_streams; i++) {
 2432             InputStream *ist = input_streams[f->ist_index + i];
 2433             int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
 2434             int64_t now = av_gettime_relative() - ist->start;
 2435             if (pts > now)
 2436                 return AVERROR(EAGAIN);
 2437         }
 2438     }
 2439 
 2440 #if HAVE_PTHREADS
 2441     if (nb_input_files > 1)
 2442         return get_input_packet_mt(f, pkt);
 2443 #endif
 2444     return av_read_frame(f->ctx, pkt);
 2445 }
 2446 
 2447 static int got_eagain(void)
 2448 {
 2449     int i;
 2450     for (i = 0; i < nb_input_files; i++)
 2451         if (input_files[i]->eagain)
 2452             return 1;
 2453     return 0;
 2454 }
 2455 
 2456 static void reset_eagain(void)
 2457 {
 2458     int i;
 2459     for (i = 0; i < nb_input_files; i++)
 2460         input_files[i]->eagain = 0;
 2461 }
 2462 
 2463 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
 2464 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
 2465                                 AVRational time_base)
 2466 {
 2467     int ret;
 2468 
 2469     if (!*duration) {
 2470         *duration = tmp;
 2471         return tmp_time_base;
 2472     }
 2473 
 2474     ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
 2475     if (ret < 0) {
 2476         *duration = tmp;
 2477         return tmp_time_base;
 2478     }
 2479 
 2480     return time_base;
 2481 }
 2482 
 2483 static int seek_to_start(InputFile *ifile, AVFormatContext *is)
 2484 {
 2485     InputStream *ist;
 2486     AVCodecContext *avctx;
 2487     int i, ret, has_audio = 0;
 2488     int64_t duration = 0;
 2489 
 2490     ret = av_seek_frame(is, -1, is->start_time, 0);
 2491     if (ret < 0)
 2492         return ret;
 2493 
 2494     for (i = 0; i < ifile->nb_streams; i++) {
 2495         ist   = input_streams[ifile->ist_index + i];
 2496         avctx = ist->dec_ctx;
 2497 
 2498         // flush decoders
 2499         if (ist->decoding_needed) {
 2500             process_input_packet(ist, NULL, 1);
 2501             avcodec_flush_buffers(avctx);
 2502         }
 2503 
 2504         /* duration is the length of the last frame in a stream
 2505          * when audio stream is present we don't care about
 2506          * last video frame length because it's not defined exactly */
 2507         if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
 2508             has_audio = 1;
 2509     }
 2510 
 2511     for (i = 0; i < ifile->nb_streams; i++) {
 2512         ist   = input_streams[ifile->ist_index + i];
 2513         avctx = ist->dec_ctx;
 2514 
 2515         if (has_audio) {
 2516             if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
 2517                 AVRational sample_rate = {1, avctx->sample_rate};
 2518 
 2519                 duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
 2520             } else
 2521                 continue;
 2522         } else {
 2523             if (ist->framerate.num) {
 2524                 duration = av_rescale_q(1, ist->framerate, ist->st->time_base);
 2525             } else if (ist->st->avg_frame_rate.num) {
 2526                 duration = av_rescale_q(1, ist->st->avg_frame_rate, ist->st->time_base);
 2527             } else duration = 1;
 2528         }
 2529         if (!ifile->duration)
 2530             ifile->time_base = ist->st->time_base;
 2531         /* the total duration of the stream, max_pts - min_pts is
 2532          * the duration of the stream without the last frame */
 2533         duration += ist->max_pts - ist->min_pts;
 2534         ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
 2535                                         ifile->time_base);
 2536     }
 2537 
 2538     if (ifile->loop > 0)
 2539         ifile->loop--;
 2540 
 2541     return ret;
 2542 }
 2543 
 2544 /*
 2545  * Read one packet from an input file and send it for
 2546  * - decoding -> lavfi (audio/video)
 2547  * - decoding -> encoding -> muxing (subtitles)
 2548  * - muxing (streamcopy)
 2549  *
 2550  * Return
 2551  * - 0 -- one packet was read and processed
 2552  * - AVERROR(EAGAIN) -- no packets were available for selected file,
 2553  *   this function should be called again
 2554  * - AVERROR_EOF -- this function should not be called again
 2555  */
 2556 static int process_input(void)
 2557 {
 2558     InputFile *ifile;
 2559     AVFormatContext *is;
 2560     InputStream *ist;
 2561     AVPacket pkt;
 2562     int ret, i, j;
 2563     int64_t duration;
 2564 
 2565     /* select the stream that we must read now */
 2566     ifile = select_input_file();
 2567     /* if none, if is finished */
 2568     if (!ifile) {
 2569         if (got_eagain()) {
 2570             reset_eagain();
 2571             av_usleep(10000);
 2572             return AVERROR(EAGAIN);
 2573         }
 2574         av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
 2575         return AVERROR_EOF;
 2576     }
 2577 
 2578     is  = ifile->ctx;
 2579     ret = get_input_packet(ifile, &pkt);
 2580 
 2581     if (ret == AVERROR(EAGAIN)) {
 2582         ifile->eagain = 1;
 2583         return ret;
 2584     }
 2585     if (ret < 0 && ifile->loop) {
 2586         if ((ret = seek_to_start(ifile, is)) < 0)
 2587             return ret;
 2588         ret = get_input_packet(ifile, &pkt);
 2589     }
 2590     if (ret < 0) {
 2591         if (ret != AVERROR_EOF) {
 2592             print_error(is->filename, ret);
 2593             if (exit_on_error)
 2594                 exit_program(1);
 2595         }
 2596         ifile->eof_reached = 1;
 2597 
 2598         for (i = 0; i < ifile->nb_streams; i++) {
 2599             ist = input_streams[ifile->ist_index + i];
 2600             if (ist->decoding_needed)
 2601                 process_input_packet(ist, NULL, 0);
 2602 
 2603             /* mark all outputs that don't go through lavfi as finished */
 2604             for (j = 0; j < nb_output_streams; j++) {
 2605                 OutputStream *ost = output_streams[j];
 2606 
 2607                 if (ost->source_index == ifile->ist_index + i &&
 2608                     (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
 2609                     finish_output_stream(ost);
 2610             }
 2611         }
 2612 
 2613         return AVERROR(EAGAIN);
 2614     }
 2615 
 2616     reset_eagain();
 2617 
 2618     if (do_pkt_dump) {
 2619         av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
 2620                          is->streams[pkt.stream_index]);
 2621     }
 2622     /* the following test is needed in case new streams appear
 2623        dynamically in stream : we ignore them */
 2624     if (pkt.stream_index >= ifile->nb_streams)
 2625         goto discard_packet;
 2626 
 2627     ist = input_streams[ifile->ist_index + pkt.stream_index];
 2628 
 2629     ist->data_size += pkt.size;
 2630     ist->nb_packets++;
 2631 
 2632     if (ist->discard)
 2633         goto discard_packet;
 2634 
 2635     /* add the stream-global side data to the first packet */
 2636     if (ist->nb_packets == 1)
 2637         for (i = 0; i < ist->st->nb_side_data; i++) {
 2638             AVPacketSideData *src_sd = &ist->st->side_data[i];
 2639             uint8_t *dst_data;
 2640 
 2641             if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
 2642                 continue;
 2643             if (ist->autorotate && src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
 2644                 continue;
 2645 
 2646             dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
 2647             if (!dst_data)
 2648                 exit_program(1);
 2649 
 2650             memcpy(dst_data, src_sd->data, src_sd->size);
 2651         }
 2652 
 2653     if (pkt.dts != AV_NOPTS_VALUE)
 2654         pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
 2655     if (pkt.pts != AV_NOPTS_VALUE)
 2656         pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
 2657 
 2658     if (pkt.pts != AV_NOPTS_VALUE)
 2659         pkt.pts *= ist->ts_scale;
 2660     if (pkt.dts != AV_NOPTS_VALUE)
 2661         pkt.dts *= ist->ts_scale;
 2662 
 2663     if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
 2664          ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) &&
 2665         pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
 2666         (is->iformat->flags & AVFMT_TS_DISCONT)) {
 2667         int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
 2668         int64_t delta   = pkt_dts - ist->next_dts;
 2669 
 2670         if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
 2671             ifile->ts_offset -= delta;
 2672             av_log(NULL, AV_LOG_DEBUG,
 2673                    "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
 2674                    delta, ifile->ts_offset);
 2675             pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
 2676             if (pkt.pts != AV_NOPTS_VALUE)
 2677                 pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
 2678         }
 2679     }
 2680     duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
 2681     if (pkt.pts != AV_NOPTS_VALUE) {
 2682         pkt.pts += duration;
 2683         ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
 2684         ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
 2685     }
 2686 
 2687     if (pkt.dts != AV_NOPTS_VALUE)
 2688         pkt.dts += duration;
 2689 
 2690     process_input_packet(ist, &pkt, 0);
 2691 
 2692 discard_packet:
 2693     av_packet_unref(&pkt);
 2694 
 2695     return 0;
 2696 }
 2697 
 2698 /*
 2699  * The following code is the main loop of the file converter
 2700  */
 2701 static int transcode(void)
 2702 {
 2703     int ret, i, need_input = 1;
 2704     AVFormatContext *os;
 2705     OutputStream *ost;
 2706     InputStream *ist;
 2707     int64_t timer_start;
 2708 
 2709     ret = transcode_init();
 2710     if (ret < 0)
 2711         goto fail;
 2712 
 2713     av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
 2714     term_init();
 2715 
 2716     timer_start = av_gettime_relative();
 2717 
 2718 #if HAVE_PTHREADS
 2719     if ((ret = init_input_threads()) < 0)
 2720         goto fail;
 2721 #endif
 2722 
 2723     while (!received_sigterm) {
 2724         /* check if there's any stream where output is still needed */
 2725         if (!need_output()) {
 2726             av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
 2727             break;
 2728         }
 2729 
 2730         /* read and process one input packet if needed */
 2731         if (need_input) {
 2732             ret = process_input();
 2733             if (ret == AVERROR_EOF)
 2734                 need_input = 0;
 2735         }
 2736 
 2737         ret = poll_filters();
 2738         if (ret < 0 && ret != AVERROR_EOF) {
 2739             char errbuf[128];
 2740             av_strerror(ret, errbuf, sizeof(errbuf));
 2741 
 2742             av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", errbuf);
 2743             break;
 2744         }
 2745 
 2746         /* dump report by using the output first video and audio streams */
 2747         print_report(0, timer_start);
 2748     }
 2749 #if HAVE_PTHREADS
 2750     free_input_threads();
 2751 #endif
 2752 
 2753     /* at the end of stream, we must flush the decoder buffers */
 2754     for (i = 0; i < nb_input_streams; i++) {
 2755         ist = input_streams[i];
 2756         if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
 2757             process_input_packet(ist, NULL, 0);
 2758         }
 2759     }
 2760     poll_filters();
 2761     flush_encoders();
 2762 
 2763     term_exit();
 2764 
 2765     /* write the trailer if needed and close file */
 2766     for (i = 0; i < nb_output_files; i++) {
 2767         os = output_files[i]->ctx;
 2768         if (!output_files[i]->header_written) {
 2769             av_log(NULL, AV_LOG_ERROR,
 2770                    "Nothing was written into output file %d (%s), because "
 2771                    "at least one of its streams received no packets.\n",
 2772                    i, os->filename);
 2773             continue;
 2774         }
 2775         av_write_trailer(os);
 2776     }
 2777 
 2778     /* dump report by using the first video and audio streams */
 2779     print_report(1, timer_start);
 2780 
 2781     /* close each encoder */
 2782     for (i = 0; i < nb_output_streams; i++) {
 2783         ost = output_streams[i];
 2784         if (ost->encoding_needed) {
 2785             av_freep(&ost->enc_ctx->stats_in);
 2786         }
 2787     }
 2788 
 2789     /* close each decoder */
 2790     for (i = 0; i < nb_input_streams; i++) {
 2791         ist = input_streams[i];
 2792         if (ist->decoding_needed) {
 2793             avcodec_close(ist->dec_ctx);
 2794             if (ist->hwaccel_uninit)
 2795                 ist->hwaccel_uninit(ist->dec_ctx);
 2796         }
 2797     }
 2798 
 2799     av_buffer_unref(&hw_device_ctx);
 2800 
 2801     /* finished ! */
 2802     ret = 0;
 2803 
 2804  fail:
 2805 #if HAVE_PTHREADS
 2806     free_input_threads();
 2807 #endif
 2808 
 2809     if (output_streams) {
 2810         for (i = 0; i < nb_output_streams; i++) {
 2811             ost = output_streams[i];
 2812             if (ost) {
 2813                 if (ost->logfile) {
 2814                     fclose(ost->logfile);
 2815                     ost->logfile = NULL;
 2816                 }
 2817                 av_free(ost->forced_kf_pts);
 2818                 av_dict_free(&ost->encoder_opts);
 2819                 av_dict_free(&ost->resample_opts);
 2820             }
 2821         }
 2822     }
 2823     return ret;
 2824 }
 2825 
 2826 static int64_t getutime(void)
 2827 {
 2828 #if HAVE_GETRUSAGE
 2829     struct rusage rusage;
 2830 
 2831     getrusage(RUSAGE_SELF, &rusage);
 2832     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
 2833 #elif HAVE_GETPROCESSTIMES
 2834     HANDLE proc;
 2835     FILETIME c, e, k, u;
 2836     proc = GetCurrentProcess();
 2837     GetProcessTimes(proc, &c, &e, &k, &u);
 2838     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
 2839 #else
 2840     return av_gettime_relative();
 2841 #endif
 2842 }
 2843 
 2844 static int64_t getmaxrss(void)
 2845 {
 2846 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
 2847     struct rusage rusage;
 2848     getrusage(RUSAGE_SELF, &rusage);
 2849     return (int64_t)rusage.ru_maxrss * 1024;
 2850 #elif HAVE_GETPROCESSMEMORYINFO
 2851     HANDLE proc;
 2852     PROCESS_MEMORY_COUNTERS memcounters;
 2853     proc = GetCurrentProcess();
 2854     memcounters.cb = sizeof(memcounters);
 2855     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
 2856     return memcounters.PeakPagefileUsage;
 2857 #else
 2858     return 0;
 2859 #endif
 2860 }
 2861 
 2862 int main(int argc, char **argv)
 2863 {
 2864     int i, ret;
 2865     int64_t ti;
 2866 
 2867     register_exit(avconv_cleanup);
 2868 
 2869     av_log_set_flags(AV_LOG_SKIP_REPEATED);
 2870     parse_loglevel(argc, argv, options);
 2871 
 2872     avcodec_register_all();
 2873 #if CONFIG_AVDEVICE
 2874     avdevice_register_all();
 2875 #endif
 2876     avfilter_register_all();
 2877     av_register_all();
 2878     avformat_network_init();
 2879 
 2880     show_banner();
 2881 
 2882     /* parse options and open all input/output files */
 2883     ret = avconv_parse_options(argc, argv);
 2884     if (ret < 0)
 2885         exit_program(1);
 2886 
 2887     if (nb_output_files <= 0 && nb_input_files == 0) {
 2888         show_usage();
 2889         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
 2890         exit_program(1);
 2891     }
 2892 
 2893     /* file converter / grab */
 2894     if (nb_output_files <= 0) {
 2895         fprintf(stderr, "At least one output file must be specified\n");
 2896         exit_program(1);
 2897     }
 2898 
 2899     for (i = 0; i < nb_output_files; i++) {
 2900         if (strcmp(output_files[i]->ctx->oformat->name, "rtp"))
 2901             want_sdp = 0;
 2902     }
 2903 
 2904     ti = getutime();
 2905     if (transcode() < 0)
 2906         exit_program(1);
 2907     ti = getutime() - ti;
 2908     if (do_benchmark) {
 2909         int maxrss = getmaxrss() / 1024;
 2910         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
 2911     }
 2912 
 2913     exit_program(0);
 2914     return 0;
 2915 }