git.sesse.net Git - ffmpeg/blob - ffmpeg.c

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   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 <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/pixdesc.h"
  43 #include "libavutil/avstring.h"
  44 #include "libavutil/libm.h"
  45 #include "libavformat/os_support.h"
  46
  47 #if CONFIG_AVFILTER
  48 # include "libavfilter/avfilter.h"
  49 # include "libavfilter/avfiltergraph.h"
  50 # include "libavfilter/vsrc_buffer.h"
  51 #endif
  52
  53 #if HAVE_SYS_RESOURCE_H
  54 #include <sys/types.h>
  55 #include <sys/time.h>
  56 #include <sys/resource.h>
  57 #elif HAVE_GETPROCESSTIMES
  58 #include <windows.h>
  59 #endif
  60 #if HAVE_GETPROCESSMEMORYINFO
  61 #include <windows.h>
  62 #include <psapi.h>
  63 #endif
  64
  65 #if HAVE_SYS_SELECT_H
  66 #include <sys/select.h>
  67 #endif
  68
  69 #include <time.h>
  70
  71 #include "cmdutils.h"
  72
  73 #include "libavutil/avassert.h"
  74
  75 const char program_name[] = "ffmpeg";
  76 const int program_birth_year = 2000;
  77
  78 /* select an input stream for an output stream */
  79 typedef struct AVStreamMap {
  80     int file_index;
  81     int stream_index;
  82     int sync_file_index;
  83     int sync_stream_index;
  84 } AVStreamMap;
  85
  86 /**
  87  * select an input file for an output file
  88  */
  89 typedef struct AVMetaDataMap {
  90     int  file;      //< file index
  91     char type;      //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
  92     int  index;     //< stream/chapter/program number
  93 } AVMetaDataMap;
  94
  95 typedef struct AVChapterMap {
  96     int in_file;
  97     int out_file;
  98 } AVChapterMap;
  99
 100 static const OptionDef options[];
 101
 102 #define MAX_FILES 100
 103 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 104
 105 #define FFM_PACKET_SIZE 4096 //XXX a duplicate of the line in ffm.h
 106
 107 static const char *last_asked_format = NULL;
 108 static AVFormatContext *input_files[MAX_FILES];
 109 static int64_t input_files_ts_offset[MAX_FILES];
 110 static double *input_files_ts_scale[MAX_FILES] = {NULL};
 111 static AVCodec **input_codecs = NULL;
 112 static int nb_input_files = 0;
 113 static int nb_input_codecs = 0;
 114 static int nb_input_files_ts_scale[MAX_FILES] = {0};
 115
 116 static AVFormatContext *output_files[MAX_FILES];
 117 static AVCodec **output_codecs = NULL;
 118 static int nb_output_files = 0;
 119 static int nb_output_codecs = 0;
 120
 121 static AVStreamMap *stream_maps = NULL;
 122 static int nb_stream_maps;
 123
 124 /* first item specifies output metadata, second is input */
 125 static AVMetaDataMap (*meta_data_maps)[2] = NULL;
 126 static int nb_meta_data_maps;
 127 static int metadata_global_autocopy   = 1;
 128 static int metadata_streams_autocopy  = 1;
 129 static int metadata_chapters_autocopy = 1;
 130
 131 static AVChapterMap *chapter_maps = NULL;
 132 static int nb_chapter_maps;
 133
 134 /* indexed by output file stream index */
 135 static int *streamid_map = NULL;
 136 static int nb_streamid_map = 0;
 137
 138 static int frame_width  = 0;
 139 static int frame_height = 0;
 140 static float frame_aspect_ratio = 0;
 141 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 142 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
 143 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 144 static AVRational frame_rate;
 145 static float video_qscale = 0;
 146 static uint16_t *intra_matrix = NULL;
 147 static uint16_t *inter_matrix = NULL;
 148 static const char *video_rc_override_string=NULL;
 149 static int video_disable = 0;
 150 static int video_discard = 0;
 151 static char *video_codec_name = NULL;
 152 static unsigned int video_codec_tag = 0;
 153 static char *video_language = NULL;
 154 static int same_quality = 0;
 155 static int do_deinterlace = 0;
 156 static int top_field_first = -1;
 157 static int me_threshold = 0;
 158 static int intra_dc_precision = 8;
 159 static int loop_input = 0;
 160 static int loop_output = AVFMT_NOOUTPUTLOOP;
 161 static int qp_hist = 0;
 162 #if CONFIG_AVFILTER
 163 static char *vfilters = NULL;
 164 static AVFilterGraph *graph = NULL;
 165 #endif
 166
 167 static int intra_only = 0;
 168 static int audio_sample_rate = 44100;
 169 static int64_t channel_layout = 0;
 170 #define QSCALE_NONE -99999
 171 static float audio_qscale = QSCALE_NONE;
 172 static int audio_disable = 0;
 173 static int audio_channels = 1;
 174 static char  *audio_codec_name = NULL;
 175 static unsigned int audio_codec_tag = 0;
 176 static char *audio_language = NULL;
 177
 178 static int subtitle_disable = 0;
 179 static char *subtitle_codec_name = NULL;
 180 static char *subtitle_language = NULL;
 181 static unsigned int subtitle_codec_tag = 0;
 182
 183 static int data_disable = 0;
 184 static char *data_codec_name = NULL;
 185 static unsigned int data_codec_tag = 0;
 186
 187 static float mux_preload= 0.5;
 188 static float mux_max_delay= 0.7;
 189
 190 static int64_t recording_time = INT64_MAX;
 191 static int64_t start_time = 0;
 192 static int64_t recording_timestamp = 0;
 193 static int64_t input_ts_offset = 0;
 194 static int file_overwrite = 0;
 195 static AVMetadata *metadata;
 196 static int do_benchmark = 0;
 197 static int do_hex_dump = 0;
 198 static int do_pkt_dump = 0;
 199 static int do_psnr = 0;
 200 static int do_pass = 0;
 201 static char *pass_logfilename_prefix = NULL;
 202 static int audio_stream_copy = 0;
 203 static int video_stream_copy = 0;
 204 static int subtitle_stream_copy = 0;
 205 static int data_stream_copy = 0;
 206 static int video_sync_method= -1;
 207 static int audio_sync_method= 0;
 208 static float audio_drift_threshold= 0.1;
 209 static int copy_ts= 0;
 210 static int copy_tb;
 211 static int opt_shortest = 0;
 212 static int video_global_header = 0;
 213 static char *vstats_filename;
 214 static FILE *vstats_file;
 215 static int opt_programid = 0;
 216 static int copy_initial_nonkeyframes = 0;
 217
 218 static int rate_emu = 0;
 219
 220 static int  video_channel = 0;
 221 static char *video_standard;
 222
 223 static int audio_volume = 256;
 224
 225 static int exit_on_error = 0;
 226 static int using_stdin = 0;
 227 static int verbose = 1;
 228 static int thread_count= 1;
 229 static int64_t video_size = 0;
 230 static int64_t audio_size = 0;
 231 static int64_t extra_size = 0;
 232 static int nb_frames_dup = 0;
 233 static int nb_frames_drop = 0;
 234 static int input_sync;
 235 static uint64_t limit_filesize = 0;
 236 static int force_fps = 0;
 237 static char *forced_key_frames = NULL;
 238
 239 static float dts_delta_threshold = 10;
 240
 241 static int64_t timer_start;
 242
 243 static uint8_t *audio_buf;
 244 static uint8_t *audio_out;
 245 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 246
 247 static short *samples;
 248
 249 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 250 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 251 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 252
 253 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 254
 255 struct AVInputStream;
 256
 257 typedef struct AVOutputStream {
 258     int file_index;          /* file index */
 259     int index;               /* stream index in the output file */
 260     int source_index;        /* AVInputStream index */
 261     AVStream *st;            /* stream in the output file */
 262     int encoding_needed;     /* true if encoding needed for this stream */
 263     int frame_number;
 264     /* input pts and corresponding output pts
 265        for A/V sync */
 266     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 267     struct AVInputStream *sync_ist; /* input stream to sync against */
 268     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 269     AVBitStreamFilterContext *bitstream_filters;
 270     /* video only */
 271     int video_resample;
 272     AVFrame pict_tmp;      /* temporary image for resampling */
 273     struct SwsContext *img_resample_ctx; /* for image resampling */
 274     int resample_height;
 275     int resample_width;
 276     int resample_pix_fmt;
 277
 278     /* forced key frames */
 279     int64_t *forced_kf_pts;
 280     int forced_kf_count;
 281     int forced_kf_index;
 282
 283     /* audio only */
 284     int audio_resample;
 285     ReSampleContext *resample; /* for audio resampling */
 286     int resample_sample_fmt;
 287     int resample_channels;
 288     int resample_sample_rate;
 289     int reformat_pair;
 290     AVAudioConvert *reformat_ctx;
 291     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 292     FILE *logfile;
 293
 294    int sws_flags;
 295 } AVOutputStream;
 296
 297 static AVOutputStream **output_streams_for_file[MAX_FILES] = { NULL };
 298 static int nb_output_streams_for_file[MAX_FILES] = { 0 };
 299
 300 typedef struct AVInputStream {
 301     int file_index;
 302     int index;
 303     AVStream *st;
 304     int discard;             /* true if stream data should be discarded */
 305     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 306     int64_t sample_index;      /* current sample */
 307
 308     int64_t       start;     /* time when read started */
 309     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 310                                 is not defined */
 311     int64_t       pts;       /* current pts */
 312     PtsCorrectionContext pts_ctx;
 313     int is_start;            /* is 1 at the start and after a discontinuity */
 314     int showed_multi_packet_warning;
 315     int is_past_recording_time;
 316 #if CONFIG_AVFILTER
 317     AVFilterContext *output_video_filter;
 318     AVFilterContext *input_video_filter;
 319     AVFrame *filter_frame;
 320     int has_filter_frame;
 321     AVFilterBufferRef *picref;
 322 #endif
 323 } AVInputStream;
 324
 325 typedef struct AVInputFile {
 326     int eof_reached;      /* true if eof reached */
 327     int ist_index;        /* index of first stream in ist_table */
 328     int buffer_size;      /* current total buffer size */
 329     int nb_streams;       /* nb streams we are aware of */
 330 } AVInputFile;
 331
 332 #if CONFIG_AVFILTER
 333
 334 static int configure_video_filters(AVInputStream *ist, AVOutputStream *ost)
 335 {
 336     AVFilterContext *last_filter, *filter;
 337     /** filter graph containing all filters including input & output */
 338     AVCodecContext *codec = ost->st->codec;
 339     AVCodecContext *icodec = ist->st->codec;
 340     FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
 341     AVRational sample_aspect_ratio;
 342     char args[255];
 343     int ret;
 344
 345     graph = avfilter_graph_alloc();
 346
 347     if (ist->st->sample_aspect_ratio.num){
 348         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 349     }else
 350         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 351
 352     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 353              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 354              sample_aspect_ratio.num, sample_aspect_ratio.den);
 355
 356     ret = avfilter_graph_create_filter(&ist->input_video_filter, avfilter_get_by_name("buffer"),
 357                                        "src", args, NULL, graph);
 358     if (ret < 0)
 359         return ret;
 360     ret = avfilter_graph_create_filter(&ist->output_video_filter, &ffsink,
 361                                        "out", NULL, &ffsink_ctx, graph);
 362     if (ret < 0)
 363         return ret;
 364     last_filter = ist->input_video_filter;
 365
 366     if (codec->width  != icodec->width || codec->height != icodec->height) {
 367         snprintf(args, 255, "%d:%d:flags=0x%X",
 368                  codec->width,
 369                  codec->height,
 370                  ost->sws_flags);
 371         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 372                                                 NULL, args, NULL, graph)) < 0)
 373             return ret;
 374         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 375             return ret;
 376         last_filter = filter;
 377     }
 378
 379     snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
 380     graph->scale_sws_opts = av_strdup(args);
 381
 382     if (vfilters) {
 383         AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
 384         AVFilterInOut *inputs  = av_malloc(sizeof(AVFilterInOut));
 385
 386         outputs->name    = av_strdup("in");
 387         outputs->filter_ctx = last_filter;
 388         outputs->pad_idx = 0;
 389         outputs->next    = NULL;
 390
 391         inputs->name    = av_strdup("out");
 392         inputs->filter_ctx = ist->output_video_filter;
 393         inputs->pad_idx = 0;
 394         inputs->next    = NULL;
 395
 396         if ((ret = avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL)) < 0)
 397             return ret;
 398         av_freep(&vfilters);
 399     } else {
 400         if ((ret = avfilter_link(last_filter, 0, ist->output_video_filter, 0)) < 0)
 401             return ret;
 402     }
 403
 404     if ((ret = avfilter_graph_config(graph, NULL)) < 0)
 405         return ret;
 406
 407     codec->width  = ist->output_video_filter->inputs[0]->w;
 408     codec->height = ist->output_video_filter->inputs[0]->h;
 409     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 410         ist->output_video_filter->inputs[0]->sample_aspect_ratio;
 411
 412     return 0;
 413 }
 414 #endif /* CONFIG_AVFILTER */
 415
 416 static void term_exit(void)
 417 {
 418     av_log(NULL, AV_LOG_QUIET, "");
 419 }
 420
 421 static volatile int received_sigterm = 0;
 422
 423 static void
 424 sigterm_handler(int sig)
 425 {
 426     received_sigterm = sig;
 427     term_exit();
 428 }
 429
 430 static void term_init(void)
 431 {
 432     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 433     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 434 #ifdef SIGXCPU
 435     signal(SIGXCPU, sigterm_handler);
 436 #endif
 437 }
 438
 439 static int decode_interrupt_cb(void)
 440 {
 441     return received_sigterm;
 442 }
 443
 444 static int ffmpeg_exit(int ret)
 445 {
 446     int i;
 447
 448     /* close files */
 449     for(i=0;i<nb_output_files;i++) {
 450         AVFormatContext *s = output_files[i];
 451         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 452             avio_close(s->pb);
 453         avformat_free_context(s);
 454         av_free(output_streams_for_file[i]);
 455     }
 456     for(i=0;i<nb_input_files;i++) {
 457         av_close_input_file(input_files[i]);
 458         av_free(input_files_ts_scale[i]);
 459     }
 460
 461     av_free(intra_matrix);
 462     av_free(inter_matrix);
 463
 464     if (vstats_file)
 465         fclose(vstats_file);
 466     av_free(vstats_filename);
 467
 468     av_free(streamid_map);
 469     av_free(input_codecs);
 470     av_free(output_codecs);
 471     av_free(stream_maps);
 472     av_free(meta_data_maps);
 473
 474     av_free(video_codec_name);
 475     av_free(audio_codec_name);
 476     av_free(subtitle_codec_name);
 477     av_free(data_codec_name);
 478
 479     av_free(video_standard);
 480
 481     uninit_opts();
 482     av_free(audio_buf);
 483     av_free(audio_out);
 484     allocated_audio_buf_size= allocated_audio_out_size= 0;
 485     av_free(samples);
 486
 487 #if CONFIG_AVFILTER
 488     avfilter_uninit();
 489 #endif
 490
 491     if (received_sigterm) {
 492         fprintf(stderr,
 493             "Received signal %d: terminating.\n",
 494             (int) received_sigterm);
 495         exit (255);
 496     }
 497
 498     exit(ret); /* not all OS-es handle main() return value */
 499     return ret;
 500 }
 501
 502 /* similar to ff_dynarray_add() and av_fast_realloc() */
 503 static void *grow_array(void *array, int elem_size, int *size, int new_size)
 504 {
 505     if (new_size >= INT_MAX / elem_size) {
 506         fprintf(stderr, "Array too big.\n");
 507         ffmpeg_exit(1);
 508     }
 509     if (*size < new_size) {
 510         uint8_t *tmp = av_realloc(array, new_size*elem_size);
 511         if (!tmp) {
 512             fprintf(stderr, "Could not alloc buffer.\n");
 513             ffmpeg_exit(1);
 514         }
 515         memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
 516         *size = new_size;
 517         return tmp;
 518     }
 519     return array;
 520 }
 521
 522 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 523 {
 524     if(codec && codec->sample_fmts){
 525         const enum AVSampleFormat *p= codec->sample_fmts;
 526         for(; *p!=-1; p++){
 527             if(*p == st->codec->sample_fmt)
 528                 break;
 529         }
 530         if (*p == -1) {
 531             av_log(NULL, AV_LOG_WARNING,
 532                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 533                    av_get_sample_fmt_name(st->codec->sample_fmt),
 534                    codec->name,
 535                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 536             st->codec->sample_fmt = codec->sample_fmts[0];
 537         }
 538     }
 539 }
 540
 541 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 542 {
 543     if(codec && codec->supported_samplerates){
 544         const int *p= codec->supported_samplerates;
 545         int best=0;
 546         int best_dist=INT_MAX;
 547         for(; *p; p++){
 548             int dist= abs(st->codec->sample_rate - *p);
 549             if(dist < best_dist){
 550                 best_dist= dist;
 551                 best= *p;
 552             }
 553         }
 554         if(best_dist){
 555             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 556         }
 557         st->codec->sample_rate= best;
 558     }
 559 }
 560
 561 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 562 {
 563     if(codec && codec->pix_fmts){
 564         const enum PixelFormat *p= codec->pix_fmts;
 565         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 566             if(st->codec->codec_id==CODEC_ID_MJPEG){
 567                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 568             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 569                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
 570             }
 571         }
 572         for(; *p!=-1; p++){
 573             if(*p == st->codec->pix_fmt)
 574                 break;
 575         }
 576         if (*p == -1) {
 577             if(st->codec->pix_fmt != PIX_FMT_NONE)
 578                 av_log(NULL, AV_LOG_WARNING,
 579                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 580                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 581                         codec->name,
 582                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 583             st->codec->pix_fmt = codec->pix_fmts[0];
 584         }
 585     }
 586 }
 587
 588 static AVOutputStream *new_output_stream(AVFormatContext *oc, int file_idx)
 589 {
 590     int idx = oc->nb_streams - 1;
 591     AVOutputStream *ost;
 592
 593     output_streams_for_file[file_idx] =
 594         grow_array(output_streams_for_file[file_idx],
 595                    sizeof(*output_streams_for_file[file_idx]),
 596                    &nb_output_streams_for_file[file_idx],
 597                    oc->nb_streams);
 598     ost = output_streams_for_file[file_idx][idx] =
 599         av_mallocz(sizeof(AVOutputStream));
 600     if (!ost) {
 601         fprintf(stderr, "Could not alloc output stream\n");
 602         ffmpeg_exit(1);
 603     }
 604     ost->file_index = file_idx;
 605     ost->index = idx;
 606
 607     ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
 608     return ost;
 609 }
 610
 611 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 612 {
 613     int i, err;
 614     AVFormatContext *ic;
 615     int nopts = 0;
 616
 617     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 618     if (err < 0)
 619         return err;
 620     /* copy stream format */
 621     s->nb_streams = 0;
 622     for(i=0;i<ic->nb_streams;i++) {
 623         AVStream *st;
 624         AVCodec *codec;
 625
 626         s->nb_streams++;
 627
 628         // FIXME: a more elegant solution is needed
 629         st = av_mallocz(sizeof(AVStream));
 630         memcpy(st, ic->streams[i], sizeof(AVStream));
 631         st->codec = avcodec_alloc_context();
 632         if (!st->codec) {
 633             print_error(filename, AVERROR(ENOMEM));
 634             ffmpeg_exit(1);
 635         }
 636         avcodec_copy_context(st->codec, ic->streams[i]->codec);
 637         s->streams[i] = st;
 638
 639         codec = avcodec_find_encoder(st->codec->codec_id);
 640         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 641             if (audio_stream_copy) {
 642                 st->stream_copy = 1;
 643             } else
 644                 choose_sample_fmt(st, codec);
 645         } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 646             if (video_stream_copy) {
 647                 st->stream_copy = 1;
 648             } else
 649                 choose_pixel_fmt(st, codec);
 650         }
 651
 652         if(st->codec->flags & CODEC_FLAG_BITEXACT)
 653             nopts = 1;
 654
 655         new_output_stream(s, nb_output_files);
 656     }
 657
 658     if (!nopts)
 659         s->timestamp = av_gettime();
 660
 661     av_close_input_file(ic);
 662     return 0;
 663 }
 664
 665 static double
 666 get_sync_ipts(const AVOutputStream *ost)
 667 {
 668     const AVInputStream *ist = ost->sync_ist;
 669     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 670 }
 671
 672 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 673     int ret;
 674
 675     while(bsfc){
 676         AVPacket new_pkt= *pkt;
 677         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 678                                           &new_pkt.data, &new_pkt.size,
 679                                           pkt->data, pkt->size,
 680                                           pkt->flags & AV_PKT_FLAG_KEY);
 681         if(a>0){
 682             av_free_packet(pkt);
 683             new_pkt.destruct= av_destruct_packet;
 684         } else if(a<0){
 685             fprintf(stderr, "%s failed for stream %d, codec %s",
 686                     bsfc->filter->name, pkt->stream_index,
 687                     avctx->codec ? avctx->codec->name : "copy");
 688             print_error("", a);
 689             if (exit_on_error)
 690                 ffmpeg_exit(1);
 691         }
 692         *pkt= new_pkt;
 693
 694         bsfc= bsfc->next;
 695     }
 696
 697     ret= av_interleaved_write_frame(s, pkt);
 698     if(ret < 0){
 699         print_error("av_interleaved_write_frame()", ret);
 700         ffmpeg_exit(1);
 701     }
 702 }
 703
 704 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 705
 706 static void do_audio_out(AVFormatContext *s,
 707                          AVOutputStream *ost,
 708                          AVInputStream *ist,
 709                          unsigned char *buf, int size)
 710 {
 711     uint8_t *buftmp;
 712     int64_t audio_out_size, audio_buf_size;
 713     int64_t allocated_for_size= size;
 714
 715     int size_out, frame_bytes, ret, resample_changed;
 716     AVCodecContext *enc= ost->st->codec;
 717     AVCodecContext *dec= ist->st->codec;
 718     int osize= av_get_bits_per_sample_fmt(enc->sample_fmt)/8;
 719     int isize= av_get_bits_per_sample_fmt(dec->sample_fmt)/8;
 720     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 721
 722 need_realloc:
 723     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 724     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 725     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 726     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 727     audio_buf_size*= osize*enc->channels;
 728
 729     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 730     if(coded_bps > 8*osize)
 731         audio_out_size= audio_out_size * coded_bps / (8*osize);
 732     audio_out_size += FF_MIN_BUFFER_SIZE;
 733
 734     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 735         fprintf(stderr, "Buffer sizes too large\n");
 736         ffmpeg_exit(1);
 737     }
 738
 739     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 740     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 741     if (!audio_buf || !audio_out){
 742         fprintf(stderr, "Out of memory in do_audio_out\n");
 743         ffmpeg_exit(1);
 744     }
 745
 746     if (enc->channels != dec->channels)
 747         ost->audio_resample = 1;
 748
 749     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 750                        ost->resample_channels    != dec->channels   ||
 751                        ost->resample_sample_rate != dec->sample_rate;
 752
 753     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 754         if (resample_changed) {
 755             av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
 756                    ist->file_index, ist->index,
 757                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 758                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 759             ost->resample_sample_fmt  = dec->sample_fmt;
 760             ost->resample_channels    = dec->channels;
 761             ost->resample_sample_rate = dec->sample_rate;
 762             if (ost->resample)
 763                 audio_resample_close(ost->resample);
 764         }
 765         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 766         if (audio_sync_method <= 1 &&
 767             ost->resample_sample_fmt  == enc->sample_fmt &&
 768             ost->resample_channels    == enc->channels   &&
 769             ost->resample_sample_rate == enc->sample_rate) {
 770             ost->resample = NULL;
 771             ost->audio_resample = 0;
 772         } else {
 773             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 774                 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 775             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 776                                                    enc->sample_rate, dec->sample_rate,
 777                                                    enc->sample_fmt,  dec->sample_fmt,
 778                                                    16, 10, 0, 0.8);
 779             if (!ost->resample) {
 780                 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 781                         dec->channels, dec->sample_rate,
 782                         enc->channels, enc->sample_rate);
 783                 ffmpeg_exit(1);
 784             }
 785         }
 786     }
 787
 788 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 789     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 790         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 791         if (ost->reformat_ctx)
 792             av_audio_convert_free(ost->reformat_ctx);
 793         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 794                                                    dec->sample_fmt, 1, NULL, 0);
 795         if (!ost->reformat_ctx) {
 796             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 797                 av_get_sample_fmt_name(dec->sample_fmt),
 798                 av_get_sample_fmt_name(enc->sample_fmt));
 799             ffmpeg_exit(1);
 800         }
 801         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 802     }
 803
 804     if(audio_sync_method){
 805         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 806                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 807         double idelta= delta*dec->sample_rate / enc->sample_rate;
 808         int byte_delta= ((int)idelta)*2*dec->channels;
 809
 810         //FIXME resample delay
 811         if(fabs(delta) > 50){
 812             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 813                 if(byte_delta < 0){
 814                     byte_delta= FFMAX(byte_delta, -size);
 815                     size += byte_delta;
 816                     buf  -= byte_delta;
 817                     if(verbose > 2)
 818                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 819                     if(!size)
 820                         return;
 821                     ist->is_start=0;
 822                 }else{
 823                     static uint8_t *input_tmp= NULL;
 824                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 825
 826                     if(byte_delta > allocated_for_size - size){
 827                         allocated_for_size= byte_delta + (int64_t)size;
 828                         goto need_realloc;
 829                     }
 830                     ist->is_start=0;
 831
 832                     memset(input_tmp, 0, byte_delta);
 833                     memcpy(input_tmp + byte_delta, buf, size);
 834                     buf= input_tmp;
 835                     size += byte_delta;
 836                     if(verbose > 2)
 837                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 838                 }
 839             }else if(audio_sync_method>1){
 840                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 841                 av_assert0(ost->audio_resample);
 842                 if(verbose > 2)
 843                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 844 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
 845                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 846             }
 847         }
 848     }else
 849         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 850                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 851
 852     if (ost->audio_resample) {
 853         buftmp = audio_buf;
 854         size_out = audio_resample(ost->resample,
 855                                   (short *)buftmp, (short *)buf,
 856                                   size / (dec->channels * isize));
 857         size_out = size_out * enc->channels * osize;
 858     } else {
 859         buftmp = buf;
 860         size_out = size;
 861     }
 862
 863     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 864         const void *ibuf[6]= {buftmp};
 865         void *obuf[6]= {audio_buf};
 866         int istride[6]= {isize};
 867         int ostride[6]= {osize};
 868         int len= size_out/istride[0];
 869         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 870             printf("av_audio_convert() failed\n");
 871             if (exit_on_error)
 872                 ffmpeg_exit(1);
 873             return;
 874         }
 875         buftmp = audio_buf;
 876         size_out = len*osize;
 877     }
 878
 879     /* now encode as many frames as possible */
 880     if (enc->frame_size > 1) {
 881         /* output resampled raw samples */
 882         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 883             fprintf(stderr, "av_fifo_realloc2() failed\n");
 884             ffmpeg_exit(1);
 885         }
 886         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 887
 888         frame_bytes = enc->frame_size * osize * enc->channels;
 889
 890         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 891             AVPacket pkt;
 892             av_init_packet(&pkt);
 893
 894             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 895
 896             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 897
 898             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 899                                        (short *)audio_buf);
 900             if (ret < 0) {
 901                 fprintf(stderr, "Audio encoding failed\n");
 902                 ffmpeg_exit(1);
 903             }
 904             audio_size += ret;
 905             pkt.stream_index= ost->index;
 906             pkt.data= audio_out;
 907             pkt.size= ret;
 908             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 909                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 910             pkt.flags |= AV_PKT_FLAG_KEY;
 911             write_frame(s, &pkt, enc, ost->bitstream_filters);
 912
 913             ost->sync_opts += enc->frame_size;
 914         }
 915     } else {
 916         AVPacket pkt;
 917         av_init_packet(&pkt);
 918
 919         ost->sync_opts += size_out / (osize * enc->channels);
 920
 921         /* output a pcm frame */
 922         /* determine the size of the coded buffer */
 923         size_out /= osize;
 924         if (coded_bps)
 925             size_out = size_out*coded_bps/8;
 926
 927         if(size_out > audio_out_size){
 928             fprintf(stderr, "Internal error, buffer size too small\n");
 929             ffmpeg_exit(1);
 930         }
 931
 932         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 933         ret = avcodec_encode_audio(enc, audio_out, size_out,
 934                                    (short *)buftmp);
 935         if (ret < 0) {
 936             fprintf(stderr, "Audio encoding failed\n");
 937             ffmpeg_exit(1);
 938         }
 939         audio_size += ret;
 940         pkt.stream_index= ost->index;
 941         pkt.data= audio_out;
 942         pkt.size= ret;
 943         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 944             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 945         pkt.flags |= AV_PKT_FLAG_KEY;
 946         write_frame(s, &pkt, enc, ost->bitstream_filters);
 947     }
 948 }
 949
 950 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 951 {
 952     AVCodecContext *dec;
 953     AVPicture *picture2;
 954     AVPicture picture_tmp;
 955     uint8_t *buf = 0;
 956
 957     dec = ist->st->codec;
 958
 959     /* deinterlace : must be done before any resize */
 960     if (do_deinterlace) {
 961         int size;
 962
 963         /* create temporary picture */
 964         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 965         buf = av_malloc(size);
 966         if (!buf)
 967             return;
 968
 969         picture2 = &picture_tmp;
 970         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 971
 972         if(avpicture_deinterlace(picture2, picture,
 973                                  dec->pix_fmt, dec->width, dec->height) < 0) {
 974             /* if error, do not deinterlace */
 975             fprintf(stderr, "Deinterlacing failed\n");
 976             av_free(buf);
 977             buf = NULL;
 978             picture2 = picture;
 979         }
 980     } else {
 981         picture2 = picture;
 982     }
 983
 984     if (picture != picture2)
 985         *picture = *picture2;
 986     *bufp = buf;
 987 }
 988
 989 /* we begin to correct av delay at this threshold */
 990 #define AV_DELAY_MAX 0.100
 991
 992 static void do_subtitle_out(AVFormatContext *s,
 993                             AVOutputStream *ost,
 994                             AVInputStream *ist,
 995                             AVSubtitle *sub,
 996                             int64_t pts)
 997 {
 998     static uint8_t *subtitle_out = NULL;
 999     int subtitle_out_max_size = 1024 * 1024;
1000     int subtitle_out_size, nb, i;
1001     AVCodecContext *enc;
1002     AVPacket pkt;
1003
1004     if (pts == AV_NOPTS_VALUE) {
1005         fprintf(stderr, "Subtitle packets must have a pts\n");
1006         if (exit_on_error)
1007             ffmpeg_exit(1);
1008         return;
1009     }
1010
1011     enc = ost->st->codec;
1012
1013     if (!subtitle_out) {
1014         subtitle_out = av_malloc(subtitle_out_max_size);
1015     }
1016
1017     /* Note: DVB subtitle need one packet to draw them and one other
1018        packet to clear them */
1019     /* XXX: signal it in the codec context ? */
1020     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1021         nb = 2;
1022     else
1023         nb = 1;
1024
1025     for(i = 0; i < nb; i++) {
1026         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1027         // start_display_time is required to be 0
1028         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1029         sub->end_display_time -= sub->start_display_time;
1030         sub->start_display_time = 0;
1031         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1032                                                     subtitle_out_max_size, sub);
1033         if (subtitle_out_size < 0) {
1034             fprintf(stderr, "Subtitle encoding failed\n");
1035             ffmpeg_exit(1);
1036         }
1037
1038         av_init_packet(&pkt);
1039         pkt.stream_index = ost->index;
1040         pkt.data = subtitle_out;
1041         pkt.size = subtitle_out_size;
1042         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1043         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1044             /* XXX: the pts correction is handled here. Maybe handling
1045                it in the codec would be better */
1046             if (i == 0)
1047                 pkt.pts += 90 * sub->start_display_time;
1048             else
1049                 pkt.pts += 90 * sub->end_display_time;
1050         }
1051         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1052     }
1053 }
1054
1055 static int bit_buffer_size= 1024*256;
1056 static uint8_t *bit_buffer= NULL;
1057
1058 static void do_video_out(AVFormatContext *s,
1059                          AVOutputStream *ost,
1060                          AVInputStream *ist,
1061                          AVFrame *in_picture,
1062                          int *frame_size)
1063 {
1064     int nb_frames, i, ret, resample_changed;
1065     AVFrame *final_picture, *formatted_picture, *resampling_dst;
1066     AVCodecContext *enc, *dec;
1067     double sync_ipts;
1068
1069     enc = ost->st->codec;
1070     dec = ist->st->codec;
1071
1072     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1073
1074     /* by default, we output a single frame */
1075     nb_frames = 1;
1076
1077     *frame_size = 0;
1078
1079     if(video_sync_method){
1080         double vdelta = sync_ipts - ost->sync_opts;
1081         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1082         if (vdelta < -1.1)
1083             nb_frames = 0;
1084         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1085             if(vdelta<=-0.6){
1086                 nb_frames=0;
1087             }else if(vdelta>0.6)
1088                 ost->sync_opts= lrintf(sync_ipts);
1089         }else if (vdelta > 1.1)
1090             nb_frames = lrintf(vdelta);
1091 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1092         if (nb_frames == 0){
1093             ++nb_frames_drop;
1094             if (verbose>2)
1095                 fprintf(stderr, "*** drop!\n");
1096         }else if (nb_frames > 1) {
1097             nb_frames_dup += nb_frames - 1;
1098             if (verbose>2)
1099                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1100         }
1101     }else
1102         ost->sync_opts= lrintf(sync_ipts);
1103
1104     nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1105     if (nb_frames <= 0)
1106         return;
1107
1108     formatted_picture = in_picture;
1109     final_picture = formatted_picture;
1110     resampling_dst = &ost->pict_tmp;
1111
1112     resample_changed = ost->resample_width   != dec->width  ||
1113                        ost->resample_height  != dec->height ||
1114                        ost->resample_pix_fmt != dec->pix_fmt;
1115
1116     if (resample_changed) {
1117         av_log(NULL, AV_LOG_INFO,
1118                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1119                ist->file_index, ist->index,
1120                ost->resample_width, ost->resample_height, avcodec_get_pix_fmt_name(ost->resample_pix_fmt),
1121                dec->width         , dec->height         , avcodec_get_pix_fmt_name(dec->pix_fmt));
1122         if(!ost->video_resample)
1123             ffmpeg_exit(1);
1124     }
1125
1126 #if !CONFIG_AVFILTER
1127     if (ost->video_resample) {
1128         final_picture = &ost->pict_tmp;
1129         if (resample_changed) {
1130             /* initialize a new scaler context */
1131             sws_freeContext(ost->img_resample_ctx);
1132             ost->img_resample_ctx = sws_getContext(
1133                 ist->st->codec->width,
1134                 ist->st->codec->height,
1135                 ist->st->codec->pix_fmt,
1136                 ost->st->codec->width,
1137                 ost->st->codec->height,
1138                 ost->st->codec->pix_fmt,
1139                 ost->sws_flags, NULL, NULL, NULL);
1140             if (ost->img_resample_ctx == NULL) {
1141                 fprintf(stderr, "Cannot get resampling context\n");
1142                 ffmpeg_exit(1);
1143             }
1144         }
1145         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1146               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1147     }
1148 #endif
1149
1150     /* duplicates frame if needed */
1151     for(i=0;i<nb_frames;i++) {
1152         AVPacket pkt;
1153         av_init_packet(&pkt);
1154         pkt.stream_index= ost->index;
1155
1156         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1157             /* raw pictures are written as AVPicture structure to
1158                avoid any copies. We support temorarily the older
1159                method. */
1160             AVFrame* old_frame = enc->coded_frame;
1161             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1162             pkt.data= (uint8_t *)final_picture;
1163             pkt.size=  sizeof(AVPicture);
1164             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1165             pkt.flags |= AV_PKT_FLAG_KEY;
1166
1167             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1168             enc->coded_frame = old_frame;
1169         } else {
1170             AVFrame big_picture;
1171
1172             big_picture= *final_picture;
1173             /* better than nothing: use input picture interlaced
1174                settings */
1175             big_picture.interlaced_frame = in_picture->interlaced_frame;
1176             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1177                 if(top_field_first == -1)
1178                     big_picture.top_field_first = in_picture->top_field_first;
1179                 else
1180                     big_picture.top_field_first = top_field_first;
1181             }
1182
1183             /* handles sameq here. This is not correct because it may
1184                not be a global option */
1185             big_picture.quality = same_quality ? ist->st->quality : ost->st->quality;
1186             if(!me_threshold)
1187                 big_picture.pict_type = 0;
1188 //            big_picture.pts = AV_NOPTS_VALUE;
1189             big_picture.pts= ost->sync_opts;
1190 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1191 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1192             if (ost->forced_kf_index < ost->forced_kf_count &&
1193                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1194                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1195                 ost->forced_kf_index++;
1196             }
1197             ret = avcodec_encode_video(enc,
1198                                        bit_buffer, bit_buffer_size,
1199                                        &big_picture);
1200             if (ret < 0) {
1201                 fprintf(stderr, "Video encoding failed\n");
1202                 ffmpeg_exit(1);
1203             }
1204
1205             if(ret>0){
1206                 pkt.data= bit_buffer;
1207                 pkt.size= ret;
1208                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1209                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1210 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1211    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1212    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1213
1214                 if(enc->coded_frame->key_frame)
1215                     pkt.flags |= AV_PKT_FLAG_KEY;
1216                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1217                 *frame_size = ret;
1218                 video_size += ret;
1219                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1220                 //        enc->frame_number-1, ret, enc->pict_type);
1221                 /* if two pass, output log */
1222                 if (ost->logfile && enc->stats_out) {
1223                     fprintf(ost->logfile, "%s", enc->stats_out);
1224                 }
1225             }
1226         }
1227         ost->sync_opts++;
1228         ost->frame_number++;
1229     }
1230 }
1231
1232 static double psnr(double d){
1233     return -10.0*log(d)/log(10.0);
1234 }
1235
1236 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1237                            int frame_size)
1238 {
1239     AVCodecContext *enc;
1240     int frame_number;
1241     double ti1, bitrate, avg_bitrate;
1242
1243     /* this is executed just the first time do_video_stats is called */
1244     if (!vstats_file) {
1245         vstats_file = fopen(vstats_filename, "w");
1246         if (!vstats_file) {
1247             perror("fopen");
1248             ffmpeg_exit(1);
1249         }
1250     }
1251
1252     enc = ost->st->codec;
1253     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1254         frame_number = ost->frame_number;
1255         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1256         if (enc->flags&CODEC_FLAG_PSNR)
1257             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1258
1259         fprintf(vstats_file,"f_size= %6d ", frame_size);
1260         /* compute pts value */
1261         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1262         if (ti1 < 0.01)
1263             ti1 = 0.01;
1264
1265         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1266         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1267         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1268             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1269         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1270     }
1271 }
1272
1273 static void print_report(AVFormatContext **output_files,
1274                          AVOutputStream **ost_table, int nb_ostreams,
1275                          int is_last_report)
1276 {
1277     char buf[1024];
1278     AVOutputStream *ost;
1279     AVFormatContext *oc;
1280     int64_t total_size;
1281     AVCodecContext *enc;
1282     int frame_number, vid, i;
1283     double bitrate, ti1, pts;
1284     static int64_t last_time = -1;
1285     static int qp_histogram[52];
1286
1287     if (!is_last_report) {
1288         int64_t cur_time;
1289         /* display the report every 0.5 seconds */
1290         cur_time = av_gettime();
1291         if (last_time == -1) {
1292             last_time = cur_time;
1293             return;
1294         }
1295         if ((cur_time - last_time) < 500000)
1296             return;
1297         last_time = cur_time;
1298     }
1299
1300
1301     oc = output_files[0];
1302
1303     total_size = avio_size(oc->pb);
1304     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1305         total_size= avio_tell(oc->pb);
1306
1307     buf[0] = '\0';
1308     ti1 = 1e10;
1309     vid = 0;
1310     for(i=0;i<nb_ostreams;i++) {
1311         float q = -1;
1312         ost = ost_table[i];
1313         enc = ost->st->codec;
1314         if (!ost->st->stream_copy && enc->coded_frame)
1315             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1316         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1317             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1318         }
1319         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1320             float t = (av_gettime()-timer_start) / 1000000.0;
1321
1322             frame_number = ost->frame_number;
1323             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1324                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1325             if(is_last_report)
1326                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1327             if(qp_hist){
1328                 int j;
1329                 int qp = lrintf(q);
1330                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1331                     qp_histogram[qp]++;
1332                 for(j=0; j<32; j++)
1333                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1334             }
1335             if (enc->flags&CODEC_FLAG_PSNR){
1336                 int j;
1337                 double error, error_sum=0;
1338                 double scale, scale_sum=0;
1339                 char type[3]= {'Y','U','V'};
1340                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1341                 for(j=0; j<3; j++){
1342                     if(is_last_report){
1343                         error= enc->error[j];
1344                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1345                     }else{
1346                         error= enc->coded_frame->error[j];
1347                         scale= enc->width*enc->height*255.0*255.0;
1348                     }
1349                     if(j) scale/=4;
1350                     error_sum += error;
1351                     scale_sum += scale;
1352                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1353                 }
1354                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1355             }
1356             vid = 1;
1357         }
1358         /* compute min output value */
1359         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1360         if ((pts < ti1) && (pts > 0))
1361             ti1 = pts;
1362     }
1363     if (ti1 < 0.01)
1364         ti1 = 0.01;
1365
1366     if (verbose > 0 || is_last_report) {
1367         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1368
1369         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1370             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1371             (double)total_size / 1024, ti1, bitrate);
1372
1373         if (nb_frames_dup || nb_frames_drop)
1374           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1375                   nb_frames_dup, nb_frames_drop);
1376
1377         if (verbose >= 0)
1378             fprintf(stderr, "%s    \r", buf);
1379
1380         fflush(stderr);
1381     }
1382
1383     if (is_last_report && verbose >= 0){
1384         int64_t raw= audio_size + video_size + extra_size;
1385         fprintf(stderr, "\n");
1386         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1387                 video_size/1024.0,
1388                 audio_size/1024.0,
1389                 extra_size/1024.0,
1390                 100.0*(total_size - raw)/raw
1391         );
1392     }
1393 }
1394
1395 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1396 {
1397     int fill_char = 0x00;
1398     if (sample_fmt == AV_SAMPLE_FMT_U8)
1399         fill_char = 0x80;
1400     memset(buf, fill_char, size);
1401 }
1402
1403 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1404 static int output_packet(AVInputStream *ist, int ist_index,
1405                          AVOutputStream **ost_table, int nb_ostreams,
1406                          const AVPacket *pkt)
1407 {
1408     AVFormatContext *os;
1409     AVOutputStream *ost;
1410     int ret, i;
1411     int got_output;
1412     AVFrame picture;
1413     void *buffer_to_free = NULL;
1414     static unsigned int samples_size= 0;
1415     AVSubtitle subtitle, *subtitle_to_free;
1416     int64_t pkt_pts = AV_NOPTS_VALUE;
1417 #if CONFIG_AVFILTER
1418     int frame_available;
1419 #endif
1420
1421     AVPacket avpkt;
1422     int bps = av_get_bits_per_sample_fmt(ist->st->codec->sample_fmt)>>3;
1423
1424     if(ist->next_pts == AV_NOPTS_VALUE)
1425         ist->next_pts= ist->pts;
1426
1427     if (pkt == NULL) {
1428         /* EOF handling */
1429         av_init_packet(&avpkt);
1430         avpkt.data = NULL;
1431         avpkt.size = 0;
1432         goto handle_eof;
1433     } else {
1434         avpkt = *pkt;
1435     }
1436
1437     if(pkt->dts != AV_NOPTS_VALUE)
1438         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1439     if(pkt->pts != AV_NOPTS_VALUE)
1440         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1441
1442     //while we have more to decode or while the decoder did output something on EOF
1443     while (avpkt.size > 0 || (!pkt && got_output)) {
1444         uint8_t *data_buf, *decoded_data_buf;
1445         int data_size, decoded_data_size;
1446     handle_eof:
1447         ist->pts= ist->next_pts;
1448
1449         if(avpkt.size && avpkt.size != pkt->size &&
1450            ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1451             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1452             ist->showed_multi_packet_warning=1;
1453         }
1454
1455         /* decode the packet if needed */
1456         decoded_data_buf = NULL; /* fail safe */
1457         decoded_data_size= 0;
1458         data_buf  = avpkt.data;
1459         data_size = avpkt.size;
1460         subtitle_to_free = NULL;
1461         if (ist->decoding_needed) {
1462             switch(ist->st->codec->codec_type) {
1463             case AVMEDIA_TYPE_AUDIO:{
1464                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1465                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1466                     av_free(samples);
1467                     samples= av_malloc(samples_size);
1468                 }
1469                 decoded_data_size= samples_size;
1470                     /* XXX: could avoid copy if PCM 16 bits with same
1471                        endianness as CPU */
1472                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1473                                             &avpkt);
1474                 if (ret < 0)
1475                     goto fail_decode;
1476                 avpkt.data += ret;
1477                 avpkt.size -= ret;
1478                 data_size   = ret;
1479                 got_output  = decoded_data_size > 0;
1480                 /* Some bug in mpeg audio decoder gives */
1481                 /* decoded_data_size < 0, it seems they are overflows */
1482                 if (!got_output) {
1483                     /* no audio frame */
1484                     continue;
1485                 }
1486                 decoded_data_buf = (uint8_t *)samples;
1487                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1488                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1489                 break;}
1490             case AVMEDIA_TYPE_VIDEO:
1491                     decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1492                     /* XXX: allocate picture correctly */
1493                     avcodec_get_frame_defaults(&picture);
1494                     avpkt.pts = pkt_pts;
1495                     avpkt.dts = ist->pts;
1496                     pkt_pts = AV_NOPTS_VALUE;
1497
1498                     ret = avcodec_decode_video2(ist->st->codec,
1499                                                 &picture, &got_output, &avpkt);
1500                     ist->st->quality= picture.quality;
1501                     if (ret < 0)
1502                         goto fail_decode;
1503                     if (!got_output) {
1504                         /* no picture yet */
1505                         goto discard_packet;
1506                     }
1507                     ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1508                     if (ist->st->codec->time_base.num != 0) {
1509                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1510                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1511                                           ist->st->codec->time_base.num * ticks) /
1512                             ist->st->codec->time_base.den;
1513                     }
1514                     avpkt.size = 0;
1515                     buffer_to_free = NULL;
1516                     pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1517                     break;
1518             case AVMEDIA_TYPE_SUBTITLE:
1519                 ret = avcodec_decode_subtitle2(ist->st->codec,
1520                                                &subtitle, &got_output, &avpkt);
1521                 if (ret < 0)
1522                     goto fail_decode;
1523                 if (!got_output) {
1524                     goto discard_packet;
1525                 }
1526                 subtitle_to_free = &subtitle;
1527                 avpkt.size = 0;
1528                 break;
1529             default:
1530                 goto fail_decode;
1531             }
1532         } else {
1533             switch(ist->st->codec->codec_type) {
1534             case AVMEDIA_TYPE_AUDIO:
1535                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1536                     ist->st->codec->sample_rate;
1537                 break;
1538             case AVMEDIA_TYPE_VIDEO:
1539                 if (ist->st->codec->time_base.num != 0) {
1540                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1541                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1542                                       ist->st->codec->time_base.num * ticks) /
1543                         ist->st->codec->time_base.den;
1544                 }
1545                 break;
1546             }
1547             ret = avpkt.size;
1548             avpkt.size = 0;
1549         }
1550
1551 #if CONFIG_AVFILTER
1552         if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) {
1553             AVRational sar;
1554             if (ist->st->sample_aspect_ratio.num) sar = ist->st->sample_aspect_ratio;
1555             else                                  sar = ist->st->codec->sample_aspect_ratio;
1556             // add it to be filtered
1557             av_vsrc_buffer_add_frame(ist->input_video_filter, &picture,
1558                                      ist->pts,
1559                                      sar);
1560         }
1561 #endif
1562
1563         // preprocess audio (volume)
1564         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1565             if (audio_volume != 256) {
1566                 short *volp;
1567                 volp = samples;
1568                 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1569                     int v = ((*volp) * audio_volume + 128) >> 8;
1570                     if (v < -32768) v = -32768;
1571                     if (v >  32767) v = 32767;
1572                     *volp++ = v;
1573                 }
1574             }
1575         }
1576
1577         /* frame rate emulation */
1578         if (rate_emu) {
1579             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1580             int64_t now = av_gettime() - ist->start;
1581             if (pts > now)
1582                 usleep(pts - now);
1583         }
1584 #if CONFIG_AVFILTER
1585         frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1586             !ist->output_video_filter || avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1587 #endif
1588         /* if output time reached then transcode raw format,
1589            encode packets and output them */
1590         if (start_time == 0 || ist->pts >= start_time)
1591 #if CONFIG_AVFILTER
1592         while (frame_available) {
1593             AVRational ist_pts_tb;
1594             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->output_video_filter)
1595                 get_filtered_video_frame(ist->output_video_filter, &picture, &ist->picref, &ist_pts_tb);
1596             if (ist->picref)
1597                 ist->pts = av_rescale_q(ist->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1598 #endif
1599             for(i=0;i<nb_ostreams;i++) {
1600                 int frame_size;
1601
1602                 ost = ost_table[i];
1603                 if (ost->source_index == ist_index) {
1604                     os = output_files[ost->file_index];
1605
1606                     /* set the input output pts pairs */
1607                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1608
1609                     if (ost->encoding_needed) {
1610                         av_assert0(ist->decoding_needed);
1611                         switch(ost->st->codec->codec_type) {
1612                         case AVMEDIA_TYPE_AUDIO:
1613                             do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1614                             break;
1615                         case AVMEDIA_TYPE_VIDEO:
1616 #if CONFIG_AVFILTER
1617                             if (ist->picref->video)
1618                                 ost->st->codec->sample_aspect_ratio = ist->picref->video->pixel_aspect;
1619 #endif
1620                             do_video_out(os, ost, ist, &picture, &frame_size);
1621                             if (vstats_filename && frame_size)
1622                                 do_video_stats(os, ost, frame_size);
1623                             break;
1624                         case AVMEDIA_TYPE_SUBTITLE:
1625                             do_subtitle_out(os, ost, ist, &subtitle,
1626                                             pkt->pts);
1627                             break;
1628                         default:
1629                             abort();
1630                         }
1631                     } else {
1632                         AVFrame avframe; //FIXME/XXX remove this
1633                         AVPacket opkt;
1634                         int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1635
1636                         av_init_packet(&opkt);
1637
1638                         if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1639                             continue;
1640
1641                         /* no reencoding needed : output the packet directly */
1642                         /* force the input stream PTS */
1643
1644                         avcodec_get_frame_defaults(&avframe);
1645                         ost->st->codec->coded_frame= &avframe;
1646                         avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1647
1648                         if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1649                             audio_size += data_size;
1650                         else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1651                             video_size += data_size;
1652                             ost->sync_opts++;
1653                         }
1654
1655                         opkt.stream_index= ost->index;
1656                         if(pkt->pts != AV_NOPTS_VALUE)
1657                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1658                         else
1659                             opkt.pts= AV_NOPTS_VALUE;
1660
1661                         if (pkt->dts == AV_NOPTS_VALUE)
1662                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1663                         else
1664                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1665                         opkt.dts -= ost_tb_start_time;
1666
1667                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1668                         opkt.flags= pkt->flags;
1669
1670                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1671                         if(   ost->st->codec->codec_id != CODEC_ID_H264
1672                            && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1673                            && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1674                            ) {
1675                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1676                                 opkt.destruct= av_destruct_packet;
1677                         } else {
1678                             opkt.data = data_buf;
1679                             opkt.size = data_size;
1680                         }
1681
1682                         write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1683                         ost->st->codec->frame_number++;
1684                         ost->frame_number++;
1685                         av_free_packet(&opkt);
1686                     }
1687                 }
1688             }
1689
1690 #if CONFIG_AVFILTER
1691             frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1692                               ist->output_video_filter && avfilter_poll_frame(ist->output_video_filter->inputs[0]);
1693             if(ist->picref)
1694                 avfilter_unref_buffer(ist->picref);
1695         }
1696 #endif
1697         av_free(buffer_to_free);
1698         /* XXX: allocate the subtitles in the codec ? */
1699         if (subtitle_to_free) {
1700             avsubtitle_free(subtitle_to_free);
1701             subtitle_to_free = NULL;
1702         }
1703     }
1704  discard_packet:
1705     if (pkt == NULL) {
1706         /* EOF handling */
1707
1708         for(i=0;i<nb_ostreams;i++) {
1709             ost = ost_table[i];
1710             if (ost->source_index == ist_index) {
1711                 AVCodecContext *enc= ost->st->codec;
1712                 os = output_files[ost->file_index];
1713
1714                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1715                     continue;
1716                 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1717                     continue;
1718
1719                 if (ost->encoding_needed) {
1720                     for(;;) {
1721                         AVPacket pkt;
1722                         int fifo_bytes;
1723                         av_init_packet(&pkt);
1724                         pkt.stream_index= ost->index;
1725
1726                         switch(ost->st->codec->codec_type) {
1727                         case AVMEDIA_TYPE_AUDIO:
1728                             fifo_bytes = av_fifo_size(ost->fifo);
1729                             ret = 0;
1730                             /* encode any samples remaining in fifo */
1731                             if (fifo_bytes > 0) {
1732                                 int osize = av_get_bits_per_sample_fmt(enc->sample_fmt) >> 3;
1733                                 int fs_tmp = enc->frame_size;
1734
1735                                 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1736                                 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1737                                     enc->frame_size = fifo_bytes / (osize * enc->channels);
1738                                 } else { /* pad */
1739                                     int frame_bytes = enc->frame_size*osize*enc->channels;
1740                                     if (allocated_audio_buf_size < frame_bytes)
1741                                         ffmpeg_exit(1);
1742                                     generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1743                                 }
1744
1745                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1746                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1747                                                           ost->st->time_base.num, enc->sample_rate);
1748                                 enc->frame_size = fs_tmp;
1749                             }
1750                             if(ret <= 0) {
1751                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1752                             }
1753                             if (ret < 0) {
1754                                 fprintf(stderr, "Audio encoding failed\n");
1755                                 ffmpeg_exit(1);
1756                             }
1757                             audio_size += ret;
1758                             pkt.flags |= AV_PKT_FLAG_KEY;
1759                             break;
1760                         case AVMEDIA_TYPE_VIDEO:
1761                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1762                             if (ret < 0) {
1763                                 fprintf(stderr, "Video encoding failed\n");
1764                                 ffmpeg_exit(1);
1765                             }
1766                             video_size += ret;
1767                             if(enc->coded_frame && enc->coded_frame->key_frame)
1768                                 pkt.flags |= AV_PKT_FLAG_KEY;
1769                             if (ost->logfile && enc->stats_out) {
1770                                 fprintf(ost->logfile, "%s", enc->stats_out);
1771                             }
1772                             break;
1773                         default:
1774                             ret=-1;
1775                         }
1776
1777                         if(ret<=0)
1778                             break;
1779                         pkt.data= bit_buffer;
1780                         pkt.size= ret;
1781                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1782                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1783                         write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1784                     }
1785                 }
1786             }
1787         }
1788     }
1789
1790     return 0;
1791  fail_decode:
1792     return -1;
1793 }
1794
1795 static void print_sdp(AVFormatContext **avc, int n)
1796 {
1797     char sdp[2048];
1798
1799     av_sdp_create(avc, n, sdp, sizeof(sdp));
1800     printf("SDP:\n%s\n", sdp);
1801     fflush(stdout);
1802 }
1803
1804 static int copy_chapters(int infile, int outfile)
1805 {
1806     AVFormatContext *is = input_files[infile];
1807     AVFormatContext *os = output_files[outfile];
1808     int i;
1809
1810     for (i = 0; i < is->nb_chapters; i++) {
1811         AVChapter *in_ch = is->chapters[i], *out_ch;
1812         int64_t ts_off   = av_rescale_q(start_time - input_files_ts_offset[infile],
1813                                       AV_TIME_BASE_Q, in_ch->time_base);
1814         int64_t rt       = (recording_time == INT64_MAX) ? INT64_MAX :
1815                            av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1816
1817
1818         if (in_ch->end < ts_off)
1819             continue;
1820         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1821             break;
1822
1823         out_ch = av_mallocz(sizeof(AVChapter));
1824         if (!out_ch)
1825             return AVERROR(ENOMEM);
1826
1827         out_ch->id        = in_ch->id;
1828         out_ch->time_base = in_ch->time_base;
1829         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1830         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1831
1832         if (metadata_chapters_autocopy)
1833             av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
1834
1835         os->nb_chapters++;
1836         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1837         if (!os->chapters)
1838             return AVERROR(ENOMEM);
1839         os->chapters[os->nb_chapters - 1] = out_ch;
1840     }
1841     return 0;
1842 }
1843
1844 static void parse_forced_key_frames(char *kf, AVOutputStream *ost,
1845                                     AVCodecContext *avctx)
1846 {
1847     char *p;
1848     int n = 1, i;
1849     int64_t t;
1850
1851     for (p = kf; *p; p++)
1852         if (*p == ',')
1853             n++;
1854     ost->forced_kf_count = n;
1855     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1856     if (!ost->forced_kf_pts) {
1857         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1858         ffmpeg_exit(1);
1859     }
1860     for (i = 0; i < n; i++) {
1861         p = i ? strchr(p, ',') + 1 : kf;
1862         t = parse_time_or_die("force_key_frames", p, 1);
1863         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1864     }
1865 }
1866
1867 /*
1868  * The following code is the main loop of the file converter
1869  */
1870 static int transcode(AVFormatContext **output_files,
1871                      int nb_output_files,
1872                      AVFormatContext **input_files,
1873                      int nb_input_files,
1874                      AVStreamMap *stream_maps, int nb_stream_maps)
1875 {
1876     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1877     AVFormatContext *is, *os;
1878     AVCodecContext *codec, *icodec;
1879     AVOutputStream *ost, **ost_table = NULL;
1880     AVInputStream *ist, **ist_table = NULL;
1881     AVInputFile *file_table;
1882     char error[1024];
1883     int want_sdp = 1;
1884     uint8_t no_packet[MAX_FILES]={0};
1885     int no_packet_count=0;
1886
1887     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1888     if (!file_table)
1889         goto fail;
1890
1891     /* input stream init */
1892     j = 0;
1893     for(i=0;i<nb_input_files;i++) {
1894         is = input_files[i];
1895         file_table[i].ist_index = j;
1896         file_table[i].nb_streams = is->nb_streams;
1897         j += is->nb_streams;
1898     }
1899     nb_istreams = j;
1900
1901     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1902     if (!ist_table)
1903         goto fail;
1904
1905     for(i=0;i<nb_istreams;i++) {
1906         ist = av_mallocz(sizeof(AVInputStream));
1907         if (!ist)
1908             goto fail;
1909         ist_table[i] = ist;
1910     }
1911     j = 0;
1912     for(i=0;i<nb_input_files;i++) {
1913         is = input_files[i];
1914         for(k=0;k<is->nb_streams;k++) {
1915             ist = ist_table[j++];
1916             ist->st = is->streams[k];
1917             ist->file_index = i;
1918             ist->index = k;
1919             ist->discard = 1; /* the stream is discarded by default
1920                                  (changed later) */
1921
1922             if (rate_emu) {
1923                 ist->start = av_gettime();
1924             }
1925         }
1926     }
1927
1928     /* output stream init */
1929     nb_ostreams = 0;
1930     for(i=0;i<nb_output_files;i++) {
1931         os = output_files[i];
1932         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1933             av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1934             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1935             ret = AVERROR(EINVAL);
1936             goto fail;
1937         }
1938         nb_ostreams += os->nb_streams;
1939     }
1940     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1941         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1942         ret = AVERROR(EINVAL);
1943         goto fail;
1944     }
1945
1946     /* Sanity check the mapping args -- do the input files & streams exist? */
1947     for(i=0;i<nb_stream_maps;i++) {
1948         int fi = stream_maps[i].file_index;
1949         int si = stream_maps[i].stream_index;
1950
1951         if (fi < 0 || fi > nb_input_files - 1 ||
1952             si < 0 || si > file_table[fi].nb_streams - 1) {
1953             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1954             ret = AVERROR(EINVAL);
1955             goto fail;
1956         }
1957         fi = stream_maps[i].sync_file_index;
1958         si = stream_maps[i].sync_stream_index;
1959         if (fi < 0 || fi > nb_input_files - 1 ||
1960             si < 0 || si > file_table[fi].nb_streams - 1) {
1961             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1962             ret = AVERROR(EINVAL);
1963             goto fail;
1964         }
1965     }
1966
1967     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1968     if (!ost_table)
1969         goto fail;
1970     n = 0;
1971     for(k=0;k<nb_output_files;k++) {
1972         os = output_files[k];
1973         for(i=0;i<os->nb_streams;i++,n++) {
1974             int found;
1975             ost = ost_table[n] = output_streams_for_file[k][i];
1976             ost->st = os->streams[i];
1977             if (nb_stream_maps > 0) {
1978                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1979                     stream_maps[n].stream_index;
1980
1981                 /* Sanity check that the stream types match */
1982                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1983                     int i= ost->file_index;
1984                     av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1985                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1986                         stream_maps[n].file_index, stream_maps[n].stream_index,
1987                         ost->file_index, ost->index);
1988                     ffmpeg_exit(1);
1989                 }
1990
1991             } else {
1992                 int best_nb_frames=-1;
1993                 /* get corresponding input stream index : we select the first one with the right type */
1994                 found = 0;
1995                 for(j=0;j<nb_istreams;j++) {
1996                     int skip=0;
1997                     ist = ist_table[j];
1998                     if(opt_programid){
1999                         int pi,si;
2000                         AVFormatContext *f= input_files[ ist->file_index ];
2001                         skip=1;
2002                         for(pi=0; pi<f->nb_programs; pi++){
2003                             AVProgram *p= f->programs[pi];
2004                             if(p->id == opt_programid)
2005                                 for(si=0; si<p->nb_stream_indexes; si++){
2006                                     if(f->streams[ p->stream_index[si] ] == ist->st)
2007                                         skip=0;
2008                                 }
2009                         }
2010                     }
2011                     if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2012                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
2013                         if(best_nb_frames < ist->st->codec_info_nb_frames){
2014                             best_nb_frames= ist->st->codec_info_nb_frames;
2015                             ost->source_index = j;
2016                             found = 1;
2017                         }
2018                     }
2019                 }
2020
2021                 if (!found) {
2022                     if(! opt_programid) {
2023                         /* try again and reuse existing stream */
2024                         for(j=0;j<nb_istreams;j++) {
2025                             ist = ist_table[j];
2026                             if (   ist->st->codec->codec_type == ost->st->codec->codec_type
2027                                 && ist->st->discard != AVDISCARD_ALL) {
2028                                 ost->source_index = j;
2029                                 found = 1;
2030                             }
2031                         }
2032                     }
2033                     if (!found) {
2034                         int i= ost->file_index;
2035                         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2036                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2037                                 ost->file_index, ost->index);
2038                         ffmpeg_exit(1);
2039                     }
2040                 }
2041             }
2042             ist = ist_table[ost->source_index];
2043             ist->discard = 0;
2044             ost->sync_ist = (nb_stream_maps > 0) ?
2045                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
2046                          stream_maps[n].sync_stream_index] : ist;
2047         }
2048     }
2049
2050     /* for each output stream, we compute the right encoding parameters */
2051     for(i=0;i<nb_ostreams;i++) {
2052         ost = ost_table[i];
2053         os = output_files[ost->file_index];
2054         ist = ist_table[ost->source_index];
2055
2056         codec = ost->st->codec;
2057         icodec = ist->st->codec;
2058
2059         if (metadata_streams_autocopy)
2060             av_metadata_copy(&ost->st->metadata, ist->st->metadata,
2061                              AV_METADATA_DONT_OVERWRITE);
2062
2063         ost->st->disposition = ist->st->disposition;
2064         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2065         codec->chroma_sample_location = icodec->chroma_sample_location;
2066
2067         if (ost->st->stream_copy) {
2068             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2069
2070             if (extra_size > INT_MAX)
2071                 goto fail;
2072
2073             /* if stream_copy is selected, no need to decode or encode */
2074             codec->codec_id = icodec->codec_id;
2075             codec->codec_type = icodec->codec_type;
2076
2077             if(!codec->codec_tag){
2078                 if(   !os->oformat->codec_tag
2079                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2080                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2081                     codec->codec_tag = icodec->codec_tag;
2082             }
2083
2084             codec->bit_rate = icodec->bit_rate;
2085             codec->rc_max_rate    = icodec->rc_max_rate;
2086             codec->rc_buffer_size = icodec->rc_buffer_size;
2087             codec->extradata= av_mallocz(extra_size);
2088             if (!codec->extradata)
2089                 goto fail;
2090             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2091             codec->extradata_size= icodec->extradata_size;
2092             if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2093                 codec->time_base = icodec->time_base;
2094                 codec->time_base.num *= icodec->ticks_per_frame;
2095                 av_reduce(&codec->time_base.num, &codec->time_base.den,
2096                           codec->time_base.num, codec->time_base.den, INT_MAX);
2097             }else
2098                 codec->time_base = ist->st->time_base;
2099             switch(codec->codec_type) {
2100             case AVMEDIA_TYPE_AUDIO:
2101                 if(audio_volume != 256) {
2102                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2103                     ffmpeg_exit(1);
2104                 }
2105                 codec->channel_layout = icodec->channel_layout;
2106                 codec->sample_rate = icodec->sample_rate;
2107                 codec->channels = icodec->channels;
2108                 codec->frame_size = icodec->frame_size;
2109                 codec->audio_service_type = icodec->audio_service_type;
2110                 codec->block_align= icodec->block_align;
2111                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2112                     codec->block_align= 0;
2113                 if(codec->codec_id == CODEC_ID_AC3)
2114                     codec->block_align= 0;
2115                 break;
2116             case AVMEDIA_TYPE_VIDEO:
2117                 codec->pix_fmt = icodec->pix_fmt;
2118                 codec->width = icodec->width;
2119                 codec->height = icodec->height;
2120                 codec->has_b_frames = icodec->has_b_frames;
2121                 break;
2122             case AVMEDIA_TYPE_SUBTITLE:
2123                 codec->width = icodec->width;
2124                 codec->height = icodec->height;
2125                 break;
2126             case AVMEDIA_TYPE_DATA:
2127                 break;
2128             default:
2129                 abort();
2130             }
2131         } else {
2132             switch(codec->codec_type) {
2133             case AVMEDIA_TYPE_AUDIO:
2134                 ost->fifo= av_fifo_alloc(1024);
2135                 if(!ost->fifo)
2136                     goto fail;
2137                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2138                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2139                 icodec->request_channels = codec->channels;
2140                 ist->decoding_needed = 1;
2141                 ost->encoding_needed = 1;
2142                 ost->resample_sample_fmt  = icodec->sample_fmt;
2143                 ost->resample_sample_rate = icodec->sample_rate;
2144                 ost->resample_channels    = icodec->channels;
2145                 break;
2146             case AVMEDIA_TYPE_VIDEO:
2147                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2148                     fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2149                     ffmpeg_exit(1);
2150                 }
2151                 ost->video_resample = codec->width   != icodec->width  ||
2152                                       codec->height  != icodec->height ||
2153                                       codec->pix_fmt != icodec->pix_fmt;
2154                 if (ost->video_resample) {
2155 #if !CONFIG_AVFILTER
2156                     avcodec_get_frame_defaults(&ost->pict_tmp);
2157                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2158                                          codec->width, codec->height)) {
2159                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2160                         ffmpeg_exit(1);
2161                     }
2162                     ost->img_resample_ctx = sws_getContext(
2163                         icodec->width,
2164                         icodec->height,
2165                             icodec->pix_fmt,
2166                             codec->width,
2167                             codec->height,
2168                             codec->pix_fmt,
2169                             ost->sws_flags, NULL, NULL, NULL);
2170                     if (ost->img_resample_ctx == NULL) {
2171                         fprintf(stderr, "Cannot get resampling context\n");
2172                         ffmpeg_exit(1);
2173                     }
2174 #endif
2175                     codec->bits_per_raw_sample= 0;
2176                 }
2177                 ost->resample_height = icodec->height;
2178                 ost->resample_width  = icodec->width;
2179                 ost->resample_pix_fmt= icodec->pix_fmt;
2180                 ost->encoding_needed = 1;
2181                 ist->decoding_needed = 1;
2182
2183 #if CONFIG_AVFILTER
2184                 if (configure_video_filters(ist, ost)) {
2185                     fprintf(stderr, "Error opening filters!\n");
2186                     exit(1);
2187                 }
2188 #endif
2189                 break;
2190             case AVMEDIA_TYPE_SUBTITLE:
2191                 ost->encoding_needed = 1;
2192                 ist->decoding_needed = 1;
2193                 break;
2194             default:
2195                 abort();
2196                 break;
2197             }
2198             /* two pass mode */
2199             if (ost->encoding_needed &&
2200                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2201                 char logfilename[1024];
2202                 FILE *f;
2203
2204                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2205                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2206                          i);
2207                 if (codec->flags & CODEC_FLAG_PASS1) {
2208                     f = fopen(logfilename, "wb");
2209                     if (!f) {
2210                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2211                         ffmpeg_exit(1);
2212                     }
2213                     ost->logfile = f;
2214                 } else {
2215                     char  *logbuffer;
2216                     size_t logbuffer_size;
2217                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2218                         fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2219                         ffmpeg_exit(1);
2220                     }
2221                     codec->stats_in = logbuffer;
2222                 }
2223             }
2224         }
2225         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2226             int size= codec->width * codec->height;
2227             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2228         }
2229     }
2230
2231     if (!bit_buffer)
2232         bit_buffer = av_malloc(bit_buffer_size);
2233     if (!bit_buffer) {
2234         fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2235                 bit_buffer_size);
2236         ret = AVERROR(ENOMEM);
2237         goto fail;
2238     }
2239
2240     /* open each encoder */
2241     for(i=0;i<nb_ostreams;i++) {
2242         ost = ost_table[i];
2243         if (ost->encoding_needed) {
2244             AVCodec *codec = i < nb_output_codecs ? output_codecs[i] : NULL;
2245             AVCodecContext *dec = ist_table[ost->source_index]->st->codec;
2246             if (!codec)
2247                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2248             if (!codec) {
2249                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2250                          ost->st->codec->codec_id, ost->file_index, ost->index);
2251                 ret = AVERROR(EINVAL);
2252                 goto dump_format;
2253             }
2254             if (dec->subtitle_header) {
2255                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2256                 if (!ost->st->codec->subtitle_header) {
2257                     ret = AVERROR(ENOMEM);
2258                     goto dump_format;
2259                 }
2260                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2261                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2262             }
2263             if (avcodec_open(ost->st->codec, codec) < 0) {
2264                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2265                         ost->file_index, ost->index);
2266                 ret = AVERROR(EINVAL);
2267                 goto dump_format;
2268             }
2269             extra_size += ost->st->codec->extradata_size;
2270         }
2271     }
2272
2273     /* open each decoder */
2274     for(i=0;i<nb_istreams;i++) {
2275         ist = ist_table[i];
2276         if (ist->decoding_needed) {
2277             AVCodec *codec = i < nb_input_codecs ? input_codecs[i] : NULL;
2278             if (!codec)
2279                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2280             if (!codec) {
2281                 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2282                         ist->st->codec->codec_id, ist->file_index, ist->index);
2283                 ret = AVERROR(EINVAL);
2284                 goto dump_format;
2285             }
2286             if (avcodec_open(ist->st->codec, codec) < 0) {
2287                 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2288                         ist->file_index, ist->index);
2289                 ret = AVERROR(EINVAL);
2290                 goto dump_format;
2291             }
2292             //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2293             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2294         }
2295     }
2296
2297     /* init pts */
2298     for(i=0;i<nb_istreams;i++) {
2299         AVStream *st;
2300         ist = ist_table[i];
2301         st= ist->st;
2302         ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2303         ist->next_pts = AV_NOPTS_VALUE;
2304         init_pts_correction(&ist->pts_ctx);
2305         ist->is_start = 1;
2306     }
2307
2308     /* set meta data information from input file if required */
2309     for (i=0;i<nb_meta_data_maps;i++) {
2310         AVFormatContext *files[2];
2311         AVMetadata      **meta[2];
2312         int j;
2313
2314 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2315         if ((index) < 0 || (index) >= (nb_elems)) {\
2316             snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2317                      (desc), (index));\
2318             ret = AVERROR(EINVAL);\
2319             goto dump_format;\
2320         }
2321
2322         int out_file_index = meta_data_maps[i][0].file;
2323         int in_file_index = meta_data_maps[i][1].file;
2324         if (in_file_index < 0 || out_file_index < 0)
2325             continue;
2326         METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2327         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2328
2329         files[0] = output_files[out_file_index];
2330         files[1] = input_files[in_file_index];
2331
2332         for (j = 0; j < 2; j++) {
2333             AVMetaDataMap *map = &meta_data_maps[i][j];
2334
2335             switch (map->type) {
2336             case 'g':
2337                 meta[j] = &files[j]->metadata;
2338                 break;
2339             case 's':
2340                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2341                 meta[j] = &files[j]->streams[map->index]->metadata;
2342                 break;
2343             case 'c':
2344                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2345                 meta[j] = &files[j]->chapters[map->index]->metadata;
2346                 break;
2347             case 'p':
2348                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2349                 meta[j] = &files[j]->programs[map->index]->metadata;
2350                 break;
2351             }
2352         }
2353
2354         av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
2355     }
2356
2357     /* copy global metadata by default */
2358     if (metadata_global_autocopy) {
2359
2360         for (i = 0; i < nb_output_files; i++)
2361             av_metadata_copy(&output_files[i]->metadata, input_files[0]->metadata,
2362                              AV_METADATA_DONT_OVERWRITE);
2363     }
2364
2365     /* copy chapters according to chapter maps */
2366     for (i = 0; i < nb_chapter_maps; i++) {
2367         int infile  = chapter_maps[i].in_file;
2368         int outfile = chapter_maps[i].out_file;
2369
2370         if (infile < 0 || outfile < 0)
2371             continue;
2372         if (infile >= nb_input_files) {
2373             snprintf(error, sizeof(error), "Invalid input file index %d in chapter mapping.\n", infile);
2374             ret = AVERROR(EINVAL);
2375             goto dump_format;
2376         }
2377         if (outfile >= nb_output_files) {
2378             snprintf(error, sizeof(error), "Invalid output file index %d in chapter mapping.\n",outfile);
2379             ret = AVERROR(EINVAL);
2380             goto dump_format;
2381         }
2382         copy_chapters(infile, outfile);
2383     }
2384
2385     /* copy chapters from the first input file that has them*/
2386     if (!nb_chapter_maps)
2387         for (i = 0; i < nb_input_files; i++) {
2388             if (!input_files[i]->nb_chapters)
2389                 continue;
2390
2391             for (j = 0; j < nb_output_files; j++)
2392                 if ((ret = copy_chapters(i, j)) < 0)
2393                     goto dump_format;
2394             break;
2395         }
2396
2397     /* open files and write file headers */
2398     for(i=0;i<nb_output_files;i++) {
2399         os = output_files[i];
2400         if (av_write_header(os) < 0) {
2401             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2402             ret = AVERROR(EINVAL);
2403             goto dump_format;
2404         }
2405         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2406             want_sdp = 0;
2407         }
2408     }
2409
2410  dump_format:
2411     /* dump the file output parameters - cannot be done before in case
2412        of stream copy */
2413     for(i=0;i<nb_output_files;i++) {
2414         av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2415     }
2416
2417     /* dump the stream mapping */
2418     if (verbose >= 0) {
2419         fprintf(stderr, "Stream mapping:\n");
2420         for(i=0;i<nb_ostreams;i++) {
2421             ost = ost_table[i];
2422             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2423                     ist_table[ost->source_index]->file_index,
2424                     ist_table[ost->source_index]->index,
2425                     ost->file_index,
2426                     ost->index);
2427             if (ost->sync_ist != ist_table[ost->source_index])
2428                 fprintf(stderr, " [sync #%d.%d]",
2429                         ost->sync_ist->file_index,
2430                         ost->sync_ist->index);
2431             fprintf(stderr, "\n");
2432         }
2433     }
2434
2435     if (ret) {
2436         fprintf(stderr, "%s\n", error);
2437         goto fail;
2438     }
2439
2440     if (want_sdp) {
2441         print_sdp(output_files, nb_output_files);
2442     }
2443
2444     if (verbose >= 0)
2445         fprintf(stderr, "Press ctrl-c to stop encoding\n");
2446     term_init();
2447
2448     timer_start = av_gettime();
2449
2450     for(; received_sigterm == 0;) {
2451         int file_index, ist_index;
2452         AVPacket pkt;
2453         double ipts_min;
2454         double opts_min;
2455
2456     redo:
2457         ipts_min= 1e100;
2458         opts_min= 1e100;
2459
2460         /* select the stream that we must read now by looking at the
2461            smallest output pts */
2462         file_index = -1;
2463         for(i=0;i<nb_ostreams;i++) {
2464             double ipts, opts;
2465             ost = ost_table[i];
2466             os = output_files[ost->file_index];
2467             ist = ist_table[ost->source_index];
2468             if(ist->is_past_recording_time || no_packet[ist->file_index])
2469                 continue;
2470                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2471             ipts = (double)ist->pts;
2472             if (!file_table[ist->file_index].eof_reached){
2473                 if(ipts < ipts_min) {
2474                     ipts_min = ipts;
2475                     if(input_sync ) file_index = ist->file_index;
2476                 }
2477                 if(opts < opts_min) {
2478                     opts_min = opts;
2479                     if(!input_sync) file_index = ist->file_index;
2480                 }
2481             }
2482             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2483                 file_index= -1;
2484                 break;
2485             }
2486         }
2487         /* if none, if is finished */
2488         if (file_index < 0) {
2489             if(no_packet_count){
2490                 no_packet_count=0;
2491                 memset(no_packet, 0, sizeof(no_packet));
2492                 usleep(10000);
2493                 continue;
2494             }
2495             break;
2496         }
2497
2498         /* finish if limit size exhausted */
2499         if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2500             break;
2501
2502         /* read a frame from it and output it in the fifo */
2503         is = input_files[file_index];
2504         ret= av_read_frame(is, &pkt);
2505         if(ret == AVERROR(EAGAIN)){
2506             no_packet[file_index]=1;
2507             no_packet_count++;
2508             continue;
2509         }
2510         if (ret < 0) {
2511             file_table[file_index].eof_reached = 1;
2512             if (opt_shortest)
2513                 break;
2514             else
2515                 continue;
2516         }
2517
2518         no_packet_count=0;
2519         memset(no_packet, 0, sizeof(no_packet));
2520
2521         if (do_pkt_dump) {
2522             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2523                              is->streams[pkt.stream_index]);
2524         }
2525         /* the following test is needed in case new streams appear
2526            dynamically in stream : we ignore them */
2527         if (pkt.stream_index >= file_table[file_index].nb_streams)
2528             goto discard_packet;
2529         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2530         ist = ist_table[ist_index];
2531         if (ist->discard)
2532             goto discard_packet;
2533
2534         if (pkt.dts != AV_NOPTS_VALUE)
2535             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2536         if (pkt.pts != AV_NOPTS_VALUE)
2537             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2538
2539         if (pkt.stream_index < nb_input_files_ts_scale[file_index]
2540             && input_files_ts_scale[file_index][pkt.stream_index]){
2541             if(pkt.pts != AV_NOPTS_VALUE)
2542                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2543             if(pkt.dts != AV_NOPTS_VALUE)
2544                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2545         }
2546
2547 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2548         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2549             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2550             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2551             int64_t delta= pkt_dts - ist->next_pts;
2552             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2553                 input_files_ts_offset[ist->file_index]-= delta;
2554                 if (verbose > 2)
2555                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2556                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2557                 if(pkt.pts != AV_NOPTS_VALUE)
2558                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2559             }
2560         }
2561
2562         /* finish if recording time exhausted */
2563         if (recording_time != INT64_MAX &&
2564             av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2565             ist->is_past_recording_time = 1;
2566             goto discard_packet;
2567         }
2568
2569         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2570         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2571
2572             if (verbose >= 0)
2573                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2574                         ist->file_index, ist->index);
2575             if (exit_on_error)
2576                 ffmpeg_exit(1);
2577             av_free_packet(&pkt);
2578             goto redo;
2579         }
2580
2581     discard_packet:
2582         av_free_packet(&pkt);
2583
2584         /* dump report by using the output first video and audio streams */
2585         print_report(output_files, ost_table, nb_ostreams, 0);
2586     }
2587
2588     /* at the end of stream, we must flush the decoder buffers */
2589     for(i=0;i<nb_istreams;i++) {
2590         ist = ist_table[i];
2591         if (ist->decoding_needed) {
2592             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2593         }
2594     }
2595
2596     term_exit();
2597
2598     /* write the trailer if needed and close file */
2599     for(i=0;i<nb_output_files;i++) {
2600         os = output_files[i];
2601         av_write_trailer(os);
2602     }
2603
2604     /* dump report by using the first video and audio streams */
2605     print_report(output_files, ost_table, nb_ostreams, 1);
2606
2607     /* close each encoder */
2608     for(i=0;i<nb_ostreams;i++) {
2609         ost = ost_table[i];
2610         if (ost->encoding_needed) {
2611             av_freep(&ost->st->codec->stats_in);
2612             avcodec_close(ost->st->codec);
2613         }
2614     }
2615
2616     /* close each decoder */
2617     for(i=0;i<nb_istreams;i++) {
2618         ist = ist_table[i];
2619         if (ist->decoding_needed) {
2620             avcodec_close(ist->st->codec);
2621         }
2622     }
2623 #if CONFIG_AVFILTER
2624     avfilter_graph_free(&graph);
2625 #endif
2626
2627     /* finished ! */
2628     ret = 0;
2629
2630  fail:
2631     av_freep(&bit_buffer);
2632     av_free(file_table);
2633
2634     if (ist_table) {
2635         for(i=0;i<nb_istreams;i++) {
2636             ist = ist_table[i];
2637             av_free(ist);
2638         }
2639         av_free(ist_table);
2640     }
2641     if (ost_table) {
2642         for(i=0;i<nb_ostreams;i++) {
2643             ost = ost_table[i];
2644             if (ost) {
2645                 if (ost->st->stream_copy)
2646                     av_freep(&ost->st->codec->extradata);
2647                 if (ost->logfile) {
2648                     fclose(ost->logfile);
2649                     ost->logfile = NULL;
2650                 }
2651                 av_fifo_free(ost->fifo); /* works even if fifo is not
2652                                              initialized but set to zero */
2653                 av_freep(&ost->st->codec->subtitle_header);
2654                 av_free(ost->pict_tmp.data[0]);
2655                 av_free(ost->forced_kf_pts);
2656                 if (ost->video_resample)
2657                     sws_freeContext(ost->img_resample_ctx);
2658                 if (ost->resample)
2659                     audio_resample_close(ost->resample);
2660                 if (ost->reformat_ctx)
2661                     av_audio_convert_free(ost->reformat_ctx);
2662                 av_free(ost);
2663             }
2664         }
2665         av_free(ost_table);
2666     }
2667     return ret;
2668 }
2669
2670 static void opt_format(const char *arg)
2671 {
2672     last_asked_format = arg;
2673 }
2674
2675 static void opt_video_rc_override_string(const char *arg)
2676 {
2677     video_rc_override_string = arg;
2678 }
2679
2680 static int opt_me_threshold(const char *opt, const char *arg)
2681 {
2682     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2683     return 0;
2684 }
2685
2686 static int opt_verbose(const char *opt, const char *arg)
2687 {
2688     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2689     return 0;
2690 }
2691
2692 static int opt_frame_rate(const char *opt, const char *arg)
2693 {
2694     if (av_parse_video_rate(&frame_rate, arg) < 0) {
2695         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2696         ffmpeg_exit(1);
2697     }
2698     return 0;
2699 }
2700
2701 static int opt_bitrate(const char *opt, const char *arg)
2702 {
2703     int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO;
2704
2705     opt_default(opt, arg);
2706
2707     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2708         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2709
2710     return 0;
2711 }
2712
2713 static int opt_frame_crop(const char *opt, const char *arg)
2714 {
2715     fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2716     return AVERROR(EINVAL);
2717 }
2718
2719 static void opt_frame_size(const char *arg)
2720 {
2721     if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2722         fprintf(stderr, "Incorrect frame size\n");
2723         ffmpeg_exit(1);
2724     }
2725 }
2726
2727 static int opt_pad(const char *opt, const char *arg) {
2728     fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2729     return -1;
2730 }
2731
2732 static void opt_frame_pix_fmt(const char *arg)
2733 {
2734     if (strcmp(arg, "list")) {
2735         frame_pix_fmt = av_get_pix_fmt(arg);
2736         if (frame_pix_fmt == PIX_FMT_NONE) {
2737             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2738             ffmpeg_exit(1);
2739         }
2740     } else {
2741         show_pix_fmts();
2742         ffmpeg_exit(0);
2743     }
2744 }
2745
2746 static void opt_frame_aspect_ratio(const char *arg)
2747 {
2748     int x = 0, y = 0;
2749     double ar = 0;
2750     const char *p;
2751     char *end;
2752
2753     p = strchr(arg, ':');
2754     if (p) {
2755         x = strtol(arg, &end, 10);
2756         if (end == p)
2757             y = strtol(end+1, &end, 10);
2758         if (x > 0 && y > 0)
2759             ar = (double)x / (double)y;
2760     } else
2761         ar = strtod(arg, NULL);
2762
2763     if (!ar) {
2764         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2765         ffmpeg_exit(1);
2766     }
2767     frame_aspect_ratio = ar;
2768
2769 #if CONFIG_AVFILTER
2770     x = vfilters ? strlen(vfilters) : 0;
2771     vfilters = av_realloc(vfilters, x+100);
2772     snprintf(vfilters+x, x+100, "%csetdar=%f\n", x?',':' ', ar);
2773 #endif
2774 }
2775
2776 static int opt_metadata(const char *opt, const char *arg)
2777 {
2778     char *mid= strchr(arg, '=');
2779
2780     if(!mid){
2781         fprintf(stderr, "Missing =\n");
2782         ffmpeg_exit(1);
2783     }
2784     *mid++= 0;
2785
2786     av_metadata_set2(&metadata, arg, mid, 0);
2787
2788     return 0;
2789 }
2790
2791 static void opt_qscale(const char *arg)
2792 {
2793     video_qscale = atof(arg);
2794     if (video_qscale <= 0 ||
2795         video_qscale > 255) {
2796         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2797         ffmpeg_exit(1);
2798     }
2799 }
2800
2801 static void opt_top_field_first(const char *arg)
2802 {
2803     top_field_first= atoi(arg);
2804 }
2805
2806 static int opt_thread_count(const char *opt, const char *arg)
2807 {
2808     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2809 #if !HAVE_THREADS
2810     if (verbose >= 0)
2811         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2812 #endif
2813     return 0;
2814 }
2815
2816 static void opt_audio_sample_fmt(const char *arg)
2817 {
2818     if (strcmp(arg, "list")) {
2819         audio_sample_fmt = av_get_sample_fmt(arg);
2820         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2821             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2822             ffmpeg_exit(1);
2823         }
2824     } else {
2825         int i;
2826         char fmt_str[128];
2827         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2828             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2829         ffmpeg_exit(0);
2830     }
2831 }
2832
2833 static int opt_audio_rate(const char *opt, const char *arg)
2834 {
2835     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2836     return 0;
2837 }
2838
2839 static int opt_audio_channels(const char *opt, const char *arg)
2840 {
2841     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2842     return 0;
2843 }
2844
2845 static void opt_video_channel(const char *arg)
2846 {
2847     video_channel = strtol(arg, NULL, 0);
2848 }
2849
2850 static void opt_video_standard(const char *arg)
2851 {
2852     video_standard = av_strdup(arg);
2853 }
2854
2855 static void opt_codec(int *pstream_copy, char **pcodec_name,
2856                       int codec_type, const char *arg)
2857 {
2858     av_freep(pcodec_name);
2859     if (!strcmp(arg, "copy")) {
2860         *pstream_copy = 1;
2861     } else {
2862         *pcodec_name = av_strdup(arg);
2863     }
2864 }
2865
2866 static void opt_audio_codec(const char *arg)
2867 {
2868     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2869 }
2870
2871 static void opt_video_codec(const char *arg)
2872 {
2873     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2874 }
2875
2876 static void opt_subtitle_codec(const char *arg)
2877 {
2878     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2879 }
2880
2881 static void opt_data_codec(const char *arg)
2882 {
2883     opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2884 }
2885
2886 static int opt_codec_tag(const char *opt, const char *arg)
2887 {
2888     char *tail;
2889     uint32_t *codec_tag;
2890
2891     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2892                 !strcmp(opt, "vtag") ? &video_codec_tag :
2893                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2894     if (!codec_tag)
2895         return -1;
2896
2897     *codec_tag = strtol(arg, &tail, 0);
2898     if (!tail || *tail)
2899         *codec_tag = AV_RL32(arg);
2900
2901     return 0;
2902 }
2903
2904 static void opt_map(const char *arg)
2905 {
2906     AVStreamMap *m;
2907     char *p;
2908
2909     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2910     m = &stream_maps[nb_stream_maps-1];
2911
2912     m->file_index = strtol(arg, &p, 0);
2913     if (*p)
2914         p++;
2915
2916     m->stream_index = strtol(p, &p, 0);
2917     if (*p) {
2918         p++;
2919         m->sync_file_index = strtol(p, &p, 0);
2920         if (*p)
2921             p++;
2922         m->sync_stream_index = strtol(p, &p, 0);
2923     } else {
2924         m->sync_file_index = m->file_index;
2925         m->sync_stream_index = m->stream_index;
2926     }
2927 }
2928
2929 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2930 {
2931     *endptr = arg;
2932     if (*arg == ',') {
2933         *type = *(++arg);
2934         switch (*arg) {
2935         case 'g':
2936             break;
2937         case 's':
2938         case 'c':
2939         case 'p':
2940             *index = strtol(++arg, endptr, 0);
2941             break;
2942         default:
2943             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2944             ffmpeg_exit(1);
2945         }
2946     } else
2947         *type = 'g';
2948 }
2949
2950 static void opt_map_metadata(const char *arg)
2951 {
2952     AVMetaDataMap *m, *m1;
2953     char *p;
2954
2955     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2956                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2957
2958     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2959     m->file = strtol(arg, &p, 0);
2960     parse_meta_type(p, &m->type, &m->index, &p);
2961     if (*p)
2962         p++;
2963
2964     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2965     m1->file = strtol(p, &p, 0);
2966     parse_meta_type(p, &m1->type, &m1->index, &p);
2967
2968     if (m->type == 'g' || m1->type == 'g')
2969         metadata_global_autocopy = 0;
2970     if (m->type == 's' || m1->type == 's')
2971         metadata_streams_autocopy = 0;
2972     if (m->type == 'c' || m1->type == 'c')
2973         metadata_chapters_autocopy = 0;
2974 }
2975
2976 static void opt_map_meta_data(const char *arg)
2977 {
2978     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2979                     "Use -map_metadata instead.\n");
2980     opt_map_metadata(arg);
2981 }
2982
2983 static void opt_map_chapters(const char *arg)
2984 {
2985     AVChapterMap *c;
2986     char *p;
2987
2988     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2989                               nb_chapter_maps + 1);
2990     c = &chapter_maps[nb_chapter_maps - 1];
2991     c->out_file = strtol(arg, &p, 0);
2992     if (*p)
2993         p++;
2994
2995     c->in_file = strtol(p, &p, 0);
2996 }
2997
2998 static void opt_input_ts_scale(const char *arg)
2999 {
3000     unsigned int stream;
3001     double scale;
3002     char *p;
3003
3004     stream = strtol(arg, &p, 0);
3005     if (*p)
3006         p++;
3007     scale= strtod(p, &p);
3008
3009     if(stream >= MAX_STREAMS)
3010         ffmpeg_exit(1);
3011
3012     input_files_ts_scale[nb_input_files] = grow_array(input_files_ts_scale[nb_input_files], sizeof(*input_files_ts_scale[nb_input_files]), &nb_input_files_ts_scale[nb_input_files], stream + 1);
3013     input_files_ts_scale[nb_input_files][stream]= scale;
3014 }
3015
3016 static int opt_recording_time(const char *opt, const char *arg)
3017 {
3018     recording_time = parse_time_or_die(opt, arg, 1);
3019     return 0;
3020 }
3021
3022 static int opt_start_time(const char *opt, const char *arg)
3023 {
3024     start_time = parse_time_or_die(opt, arg, 1);
3025     return 0;
3026 }
3027
3028 static int opt_recording_timestamp(const char *opt, const char *arg)
3029 {
3030     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3031     return 0;
3032 }
3033
3034 static int opt_input_ts_offset(const char *opt, const char *arg)
3035 {
3036     input_ts_offset = parse_time_or_die(opt, arg, 1);
3037     return 0;
3038 }
3039
3040 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3041 {
3042     const char *codec_string = encoder ? "encoder" : "decoder";
3043     AVCodec *codec;
3044
3045     if(!name)
3046         return CODEC_ID_NONE;
3047     codec = encoder ?
3048         avcodec_find_encoder_by_name(name) :
3049         avcodec_find_decoder_by_name(name);
3050     if(!codec) {
3051         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3052         ffmpeg_exit(1);
3053     }
3054     if(codec->type != type) {
3055         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3056         ffmpeg_exit(1);
3057     }
3058     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3059        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3060         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3061                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3062                 codec_string, codec->name);
3063         codec = encoder ?
3064             avcodec_find_encoder(codec->id) :
3065             avcodec_find_decoder(codec->id);
3066         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3067             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3068                     codec_string, codec->name);
3069         ffmpeg_exit(1);
3070     }
3071     return codec->id;
3072 }
3073
3074 static void opt_input_file(const char *filename)
3075 {
3076     AVFormatContext *ic;
3077     AVFormatParameters params, *ap = &params;
3078     AVInputFormat *file_iformat = NULL;
3079     int err, i, ret, rfps, rfps_base;
3080     int64_t timestamp;
3081
3082     if (last_asked_format) {
3083         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3084             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3085             ffmpeg_exit(1);
3086         }
3087         last_asked_format = NULL;
3088     }
3089
3090     if (!strcmp(filename, "-"))
3091         filename = "pipe:";
3092
3093     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3094                     !strcmp(filename, "/dev/stdin");
3095
3096     /* get default parameters from command line */
3097     ic = avformat_alloc_context();
3098     if (!ic) {
3099         print_error(filename, AVERROR(ENOMEM));
3100         ffmpeg_exit(1);
3101     }
3102
3103     memset(ap, 0, sizeof(*ap));
3104     ap->prealloced_context = 1;
3105     ap->sample_rate = audio_sample_rate;
3106     ap->channels = audio_channels;
3107     ap->time_base.den = frame_rate.num;
3108     ap->time_base.num = frame_rate.den;
3109     ap->width = frame_width;
3110     ap->height = frame_height;
3111     ap->pix_fmt = frame_pix_fmt;
3112    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3113     ap->channel = video_channel;
3114     ap->standard = video_standard;
3115
3116     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3117
3118     ic->video_codec_id   =
3119         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3120                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3121     ic->audio_codec_id   =
3122         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3123                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3124     ic->subtitle_codec_id=
3125         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3126                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3127     ic->flags |= AVFMT_FLAG_NONBLOCK;
3128
3129     /* open the input file with generic libav function */
3130     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3131     if (err < 0) {
3132         print_error(filename, err);
3133         ffmpeg_exit(1);
3134     }
3135     if(opt_programid) {
3136         int i, j;
3137         int found=0;
3138         for(i=0; i<ic->nb_streams; i++){
3139             ic->streams[i]->discard= AVDISCARD_ALL;
3140         }
3141         for(i=0; i<ic->nb_programs; i++){
3142             AVProgram *p= ic->programs[i];
3143             if(p->id != opt_programid){
3144                 p->discard = AVDISCARD_ALL;
3145             }else{
3146                 found=1;
3147                 for(j=0; j<p->nb_stream_indexes; j++){
3148                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3149                 }
3150             }
3151         }
3152         if(!found){
3153             fprintf(stderr, "Specified program id not found\n");
3154             ffmpeg_exit(1);
3155         }
3156         opt_programid=0;
3157     }
3158
3159     ic->loop_input = loop_input;
3160
3161     /* If not enough info to get the stream parameters, we decode the
3162        first frames to get it. (used in mpeg case for example) */
3163     ret = av_find_stream_info(ic);
3164     if (ret < 0 && verbose >= 0) {
3165         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3166         av_close_input_file(ic);
3167         ffmpeg_exit(1);
3168     }
3169
3170     timestamp = start_time;
3171     /* add the stream start time */
3172     if (ic->start_time != AV_NOPTS_VALUE)
3173         timestamp += ic->start_time;
3174
3175     /* if seeking requested, we execute it */
3176     if (start_time != 0) {
3177         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3178         if (ret < 0) {
3179             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3180                     filename, (double)timestamp / AV_TIME_BASE);
3181         }
3182         /* reset seek info */
3183         start_time = 0;
3184     }
3185
3186     /* update the current parameters so that they match the one of the input stream */
3187     for(i=0;i<ic->nb_streams;i++) {
3188         AVStream *st = ic->streams[i];
3189         AVCodecContext *dec = st->codec;
3190         dec->thread_count = thread_count;
3191         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3192         switch (dec->codec_type) {
3193         case AVMEDIA_TYPE_AUDIO:
3194             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3195             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3196             channel_layout    = dec->channel_layout;
3197             audio_channels    = dec->channels;
3198             audio_sample_rate = dec->sample_rate;
3199             audio_sample_fmt  = dec->sample_fmt;
3200             if(audio_disable)
3201                 st->discard= AVDISCARD_ALL;
3202             /* Note that av_find_stream_info can add more streams, and we
3203              * currently have no chance of setting up lowres decoding
3204              * early enough for them. */
3205             if (dec->lowres)
3206                 audio_sample_rate >>= dec->lowres;
3207             break;
3208         case AVMEDIA_TYPE_VIDEO:
3209             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3210             set_context_opts(dec, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, input_codecs[nb_input_codecs-1]);
3211             frame_height = dec->height;
3212             frame_width  = dec->width;
3213             if(ic->streams[i]->sample_aspect_ratio.num)
3214                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3215             else
3216                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3217             frame_aspect_ratio *= (float) dec->width / dec->height;
3218             frame_pix_fmt = dec->pix_fmt;
3219             rfps      = ic->streams[i]->r_frame_rate.num;
3220             rfps_base = ic->streams[i]->r_frame_rate.den;
3221             if (dec->lowres) {
3222                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3223                 frame_height >>= dec->lowres;
3224                 frame_width  >>= dec->lowres;
3225                 dec->height = frame_height;
3226                 dec->width  = frame_width;
3227             }
3228             if(me_threshold)
3229                 dec->debug |= FF_DEBUG_MV;
3230
3231             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3232
3233                 if (verbose >= 0)
3234                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3235                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3236
3237                     (float)rfps / rfps_base, rfps, rfps_base);
3238             }
3239             /* update the current frame rate to match the stream frame rate */
3240             frame_rate.num = rfps;
3241             frame_rate.den = rfps_base;
3242
3243             if(video_disable)
3244                 st->discard= AVDISCARD_ALL;
3245             else if(video_discard)
3246                 st->discard= video_discard;
3247             break;
3248         case AVMEDIA_TYPE_DATA:
3249             break;
3250         case AVMEDIA_TYPE_SUBTITLE:
3251             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3252             if(subtitle_disable)
3253                 st->discard = AVDISCARD_ALL;
3254             break;
3255         case AVMEDIA_TYPE_ATTACHMENT:
3256         case AVMEDIA_TYPE_UNKNOWN:
3257             break;
3258         default:
3259             abort();
3260         }
3261     }
3262
3263     input_files[nb_input_files] = ic;
3264     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3265     /* dump the file content */
3266     if (verbose >= 0)
3267         av_dump_format(ic, nb_input_files, filename, 0);
3268
3269     nb_input_files++;
3270
3271     video_channel = 0;
3272
3273     av_freep(&video_codec_name);
3274     av_freep(&audio_codec_name);
3275     av_freep(&subtitle_codec_name);
3276     uninit_opts();
3277     init_opts();
3278 }
3279
3280 static void check_inputs(int *has_video_ptr,
3281                          int *has_audio_ptr,
3282                          int *has_subtitle_ptr,
3283                          int *has_data_ptr)
3284 {
3285     int has_video, has_audio, has_subtitle, has_data, i, j;
3286     AVFormatContext *ic;
3287
3288     has_video = 0;
3289     has_audio = 0;
3290     has_subtitle = 0;
3291     has_data = 0;
3292
3293     for(j=0;j<nb_input_files;j++) {
3294         ic = input_files[j];
3295         for(i=0;i<ic->nb_streams;i++) {
3296             AVCodecContext *enc = ic->streams[i]->codec;
3297             switch(enc->codec_type) {
3298             case AVMEDIA_TYPE_AUDIO:
3299                 has_audio = 1;
3300                 break;
3301             case AVMEDIA_TYPE_VIDEO:
3302                 has_video = 1;
3303                 break;
3304             case AVMEDIA_TYPE_SUBTITLE:
3305                 has_subtitle = 1;
3306                 break;
3307             case AVMEDIA_TYPE_DATA:
3308             case AVMEDIA_TYPE_ATTACHMENT:
3309             case AVMEDIA_TYPE_UNKNOWN:
3310                 has_data = 1;
3311                 break;
3312             default:
3313                 abort();
3314             }
3315         }
3316     }
3317     *has_video_ptr = has_video;
3318     *has_audio_ptr = has_audio;
3319     *has_subtitle_ptr = has_subtitle;
3320     *has_data_ptr = has_data;
3321 }
3322
3323 static void new_video_stream(AVFormatContext *oc, int file_idx)
3324 {
3325     AVStream *st;
3326     AVOutputStream *ost;
3327     AVCodecContext *video_enc;
3328     enum CodecID codec_id = CODEC_ID_NONE;
3329     AVCodec *codec= NULL;
3330
3331     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3332     if (!st) {
3333         fprintf(stderr, "Could not alloc stream\n");
3334         ffmpeg_exit(1);
3335     }
3336     ost = new_output_stream(oc, file_idx);
3337
3338     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3339     if(!video_stream_copy){
3340         if (video_codec_name) {
3341             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3342                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3343             codec = avcodec_find_encoder_by_name(video_codec_name);
3344             output_codecs[nb_output_codecs-1] = codec;
3345         } else {
3346             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3347             codec = avcodec_find_encoder(codec_id);
3348         }
3349     }
3350
3351     avcodec_get_context_defaults3(st->codec, codec);
3352     ost->bitstream_filters = video_bitstream_filters;
3353     video_bitstream_filters= NULL;
3354
3355     st->codec->thread_count= thread_count;
3356
3357     video_enc = st->codec;
3358
3359     if(video_codec_tag)
3360         video_enc->codec_tag= video_codec_tag;
3361
3362     if(   (video_global_header&1)
3363        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3364         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3365         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3366     }
3367     if(video_global_header&2){
3368         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3369         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3370     }
3371
3372     if (video_stream_copy) {
3373         st->stream_copy = 1;
3374         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3375         video_enc->sample_aspect_ratio =
3376         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3377     } else {
3378         const char *p;
3379         int i;
3380         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3381
3382         video_enc->codec_id = codec_id;
3383         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3384
3385         if (codec && codec->supported_framerates && !force_fps)
3386             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3387         video_enc->time_base.den = fps.num;
3388         video_enc->time_base.num = fps.den;
3389
3390         video_enc->width = frame_width;
3391         video_enc->height = frame_height;
3392         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3393         video_enc->pix_fmt = frame_pix_fmt;
3394         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3395
3396         choose_pixel_fmt(st, codec);
3397
3398         if (intra_only)
3399             video_enc->gop_size = 0;
3400         if (video_qscale || same_quality) {
3401             video_enc->flags |= CODEC_FLAG_QSCALE;
3402             video_enc->global_quality=
3403                 st->quality = FF_QP2LAMBDA * video_qscale;
3404         }
3405
3406         if(intra_matrix)
3407             video_enc->intra_matrix = intra_matrix;
3408         if(inter_matrix)
3409             video_enc->inter_matrix = inter_matrix;
3410
3411         p= video_rc_override_string;
3412         for(i=0; p; i++){
3413             int start, end, q;
3414             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3415             if(e!=3){
3416                 fprintf(stderr, "error parsing rc_override\n");
3417                 ffmpeg_exit(1);
3418             }
3419             video_enc->rc_override=
3420                 av_realloc(video_enc->rc_override,
3421                            sizeof(RcOverride)*(i+1));
3422             video_enc->rc_override[i].start_frame= start;
3423             video_enc->rc_override[i].end_frame  = end;
3424             if(q>0){
3425                 video_enc->rc_override[i].qscale= q;
3426                 video_enc->rc_override[i].quality_factor= 1.0;
3427             }
3428             else{
3429                 video_enc->rc_override[i].qscale= 0;
3430                 video_enc->rc_override[i].quality_factor= -q/100.0;
3431             }
3432             p= strchr(p, '/');
3433             if(p) p++;
3434         }
3435         video_enc->rc_override_count=i;
3436         if (!video_enc->rc_initial_buffer_occupancy)
3437             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3438         video_enc->me_threshold= me_threshold;
3439         video_enc->intra_dc_precision= intra_dc_precision - 8;
3440
3441         if (do_psnr)
3442             video_enc->flags|= CODEC_FLAG_PSNR;
3443
3444         /* two pass mode */
3445         if (do_pass) {
3446             if (do_pass == 1) {
3447                 video_enc->flags |= CODEC_FLAG_PASS1;
3448             } else {
3449                 video_enc->flags |= CODEC_FLAG_PASS2;
3450             }
3451         }
3452
3453         if (forced_key_frames)
3454             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3455     }
3456     if (video_language) {
3457         av_metadata_set2(&st->metadata, "language", video_language, 0);
3458         av_freep(&video_language);
3459     }
3460
3461     /* reset some key parameters */
3462     video_disable = 0;
3463     av_freep(&video_codec_name);
3464     av_freep(&forced_key_frames);
3465     video_stream_copy = 0;
3466     frame_pix_fmt = PIX_FMT_NONE;
3467 }
3468
3469 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3470 {
3471     AVStream *st;
3472     AVOutputStream *ost;
3473     AVCodec *codec= NULL;
3474     AVCodecContext *audio_enc;
3475     enum CodecID codec_id = CODEC_ID_NONE;
3476
3477     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3478     if (!st) {
3479         fprintf(stderr, "Could not alloc stream\n");
3480         ffmpeg_exit(1);
3481     }
3482     ost = new_output_stream(oc, file_idx);
3483
3484     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3485     if(!audio_stream_copy){
3486         if (audio_codec_name) {
3487             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3488                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3489             codec = avcodec_find_encoder_by_name(audio_codec_name);
3490             output_codecs[nb_output_codecs-1] = codec;
3491         } else {
3492             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3493             codec = avcodec_find_encoder(codec_id);
3494         }
3495     }
3496
3497     avcodec_get_context_defaults3(st->codec, codec);
3498
3499     ost->bitstream_filters = audio_bitstream_filters;
3500     audio_bitstream_filters= NULL;
3501
3502     st->codec->thread_count= thread_count;
3503
3504     audio_enc = st->codec;
3505     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3506
3507     if(audio_codec_tag)
3508         audio_enc->codec_tag= audio_codec_tag;
3509
3510     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3511         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3512         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3513     }
3514     if (audio_stream_copy) {
3515         st->stream_copy = 1;
3516         audio_enc->channels = audio_channels;
3517         audio_enc->sample_rate = audio_sample_rate;
3518     } else {
3519         audio_enc->codec_id = codec_id;
3520         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3521
3522         if (audio_qscale > QSCALE_NONE) {
3523             audio_enc->flags |= CODEC_FLAG_QSCALE;
3524             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3525         }
3526         audio_enc->channels = audio_channels;
3527         audio_enc->sample_fmt = audio_sample_fmt;
3528         audio_enc->sample_rate = audio_sample_rate;
3529         audio_enc->channel_layout = channel_layout;
3530         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3531             audio_enc->channel_layout = 0;
3532         choose_sample_fmt(st, codec);
3533         choose_sample_rate(st, codec);
3534     }
3535     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3536     if (audio_language) {
3537         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3538         av_freep(&audio_language);
3539     }
3540
3541     /* reset some key parameters */
3542     audio_disable = 0;
3543     av_freep(&audio_codec_name);
3544     audio_stream_copy = 0;
3545 }
3546
3547 static void new_data_stream(AVFormatContext *oc, int file_idx)
3548 {
3549     AVStream *st;
3550     AVOutputStream *ost;
3551     AVCodec *codec=NULL;
3552     AVCodecContext *data_enc;
3553
3554     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3555     if (!st) {
3556         fprintf(stderr, "Could not alloc stream\n");
3557         ffmpeg_exit(1);
3558     }
3559     ost = new_output_stream(oc, file_idx);
3560     data_enc = st->codec;
3561     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3562     if (!data_stream_copy) {
3563         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3564         ffmpeg_exit(1);
3565     }
3566     avcodec_get_context_defaults3(st->codec, codec);
3567
3568     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3569
3570     if (data_codec_tag)
3571         data_enc->codec_tag= data_codec_tag;
3572
3573     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3574         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3575         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3576     }
3577     if (data_stream_copy) {
3578         st->stream_copy = 1;
3579     }
3580
3581     data_disable = 0;
3582     av_freep(&data_codec_name);
3583     data_stream_copy = 0;
3584 }
3585
3586 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3587 {
3588     AVStream *st;
3589     AVOutputStream *ost;
3590     AVCodec *codec=NULL;
3591     AVCodecContext *subtitle_enc;
3592     enum CodecID codec_id = CODEC_ID_NONE;
3593
3594     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3595     if (!st) {
3596         fprintf(stderr, "Could not alloc stream\n");
3597         ffmpeg_exit(1);
3598     }
3599     ost = new_output_stream(oc, file_idx);
3600     subtitle_enc = st->codec;
3601     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3602     if(!subtitle_stream_copy){
3603         if (subtitle_codec_name) {
3604             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3605                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3606             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3607         } else {
3608             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3609             codec = avcodec_find_encoder(codec_id);
3610         }
3611     }
3612     avcodec_get_context_defaults3(st->codec, codec);
3613
3614     ost->bitstream_filters = subtitle_bitstream_filters;
3615     subtitle_bitstream_filters= NULL;
3616
3617     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3618
3619     if(subtitle_codec_tag)
3620         subtitle_enc->codec_tag= subtitle_codec_tag;
3621
3622     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3623         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3624         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3625     }
3626     if (subtitle_stream_copy) {
3627         st->stream_copy = 1;
3628     } else {
3629         subtitle_enc->codec_id = codec_id;
3630         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3631     }
3632
3633     if (subtitle_language) {
3634         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3635         av_freep(&subtitle_language);
3636     }
3637
3638     subtitle_disable = 0;
3639     av_freep(&subtitle_codec_name);
3640     subtitle_stream_copy = 0;
3641 }
3642
3643 static int opt_new_stream(const char *opt, const char *arg)
3644 {
3645     AVFormatContext *oc;
3646     int file_idx = nb_output_files - 1;
3647     if (nb_output_files <= 0) {
3648         fprintf(stderr, "At least one output file must be specified\n");
3649         ffmpeg_exit(1);
3650     }
3651     oc = output_files[file_idx];
3652
3653     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3654     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3655     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3656     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3657     else av_assert0(0);
3658     return 0;
3659 }
3660
3661 /* arg format is "output-stream-index:streamid-value". */
3662 static int opt_streamid(const char *opt, const char *arg)
3663 {
3664     int idx;
3665     char *p;
3666     char idx_str[16];
3667
3668     av_strlcpy(idx_str, arg, sizeof(idx_str));
3669     p = strchr(idx_str, ':');
3670     if (!p) {
3671         fprintf(stderr,
3672                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3673                 arg, opt);
3674         ffmpeg_exit(1);
3675     }
3676     *p++ = '\0';
3677     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3678     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3679     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3680     return 0;
3681 }
3682
3683 static void opt_output_file(const char *filename)
3684 {
3685     AVFormatContext *oc;
3686     int err, use_video, use_audio, use_subtitle, use_data;
3687     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3688     AVFormatParameters params, *ap = &params;
3689     AVOutputFormat *file_oformat;
3690
3691     if (!strcmp(filename, "-"))
3692         filename = "pipe:";
3693
3694     oc = avformat_alloc_context();
3695     if (!oc) {
3696         print_error(filename, AVERROR(ENOMEM));
3697         ffmpeg_exit(1);
3698     }
3699
3700     if (last_asked_format) {
3701         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3702         if (!file_oformat) {
3703             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3704             ffmpeg_exit(1);
3705         }
3706         last_asked_format = NULL;
3707     } else {
3708         file_oformat = av_guess_format(NULL, filename, NULL);
3709         if (!file_oformat) {
3710             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3711                     filename);
3712             ffmpeg_exit(1);
3713         }
3714     }
3715
3716     oc->oformat = file_oformat;
3717     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3718
3719     if (!strcmp(file_oformat->name, "ffm") &&
3720         av_strstart(filename, "http:", NULL)) {
3721         /* special case for files sent to ffserver: we get the stream
3722            parameters from ffserver */
3723         int err = read_ffserver_streams(oc, filename);
3724         if (err < 0) {
3725             print_error(filename, err);
3726             ffmpeg_exit(1);
3727         }
3728     } else {
3729         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3730         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3731         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3732         use_data = data_stream_copy ||  data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3733
3734         /* disable if no corresponding type found and at least one
3735            input file */
3736         if (nb_input_files > 0) {
3737             check_inputs(&input_has_video,
3738                          &input_has_audio,
3739                          &input_has_subtitle,
3740                          &input_has_data);
3741
3742             if (!input_has_video)
3743                 use_video = 0;
3744             if (!input_has_audio)
3745                 use_audio = 0;
3746             if (!input_has_subtitle)
3747                 use_subtitle = 0;
3748             if (!input_has_data)
3749                 use_data = 0;
3750         }
3751
3752         /* manual disable */
3753         if (audio_disable)    use_audio    = 0;
3754         if (video_disable)    use_video    = 0;
3755         if (subtitle_disable) use_subtitle = 0;
3756         if (data_disable)     use_data     = 0;
3757
3758         if (use_video)    new_video_stream(oc, nb_output_files);
3759         if (use_audio)    new_audio_stream(oc, nb_output_files);
3760         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3761         if (use_data)     new_data_stream(oc, nb_output_files);
3762
3763         oc->timestamp = recording_timestamp;
3764
3765         av_metadata_copy(&oc->metadata, metadata, 0);
3766         av_metadata_free(&metadata);
3767     }
3768
3769     output_files[nb_output_files++] = oc;
3770
3771     /* check filename in case of an image number is expected */
3772     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3773         if (!av_filename_number_test(oc->filename)) {
3774             print_error(oc->filename, AVERROR(EINVAL));
3775             ffmpeg_exit(1);
3776         }
3777     }
3778
3779     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3780         /* test if it already exists to avoid loosing precious files */
3781         if (!file_overwrite &&
3782             (strchr(filename, ':') == NULL ||
3783              filename[1] == ':' ||
3784              av_strstart(filename, "file:", NULL))) {
3785             if (avio_check(filename, 0) == 0) {
3786                 if (!using_stdin) {
3787                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3788                     fflush(stderr);
3789                     if (!read_yesno()) {
3790                         fprintf(stderr, "Not overwriting - exiting\n");
3791                         ffmpeg_exit(1);
3792                     }
3793                 }
3794                 else {
3795                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3796                     ffmpeg_exit(1);
3797                 }
3798             }
3799         }
3800
3801         /* open the file */
3802         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3803             print_error(filename, err);
3804             ffmpeg_exit(1);
3805         }
3806     }
3807
3808     memset(ap, 0, sizeof(*ap));
3809     if (av_set_parameters(oc, ap) < 0) {
3810         fprintf(stderr, "%s: Invalid encoding parameters\n",
3811                 oc->filename);
3812         ffmpeg_exit(1);
3813     }
3814
3815     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3816     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3817     oc->loop_output = loop_output;
3818     oc->flags |= AVFMT_FLAG_NONBLOCK;
3819
3820     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3821
3822     av_freep(&forced_key_frames);
3823     uninit_opts();
3824     init_opts();
3825 }
3826
3827 /* same option as mencoder */
3828 static void opt_pass(const char *pass_str)
3829 {
3830     int pass;
3831     pass = atoi(pass_str);
3832     if (pass != 1 && pass != 2) {
3833         fprintf(stderr, "pass number can be only 1 or 2\n");
3834         ffmpeg_exit(1);
3835     }
3836     do_pass = pass;
3837 }
3838
3839 static int64_t getutime(void)
3840 {
3841 #if HAVE_GETRUSAGE
3842     struct rusage rusage;
3843
3844     getrusage(RUSAGE_SELF, &rusage);
3845     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3846 #elif HAVE_GETPROCESSTIMES
3847     HANDLE proc;
3848     FILETIME c, e, k, u;
3849     proc = GetCurrentProcess();
3850     GetProcessTimes(proc, &c, &e, &k, &u);
3851     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3852 #else
3853     return av_gettime();
3854 #endif
3855 }
3856
3857 static int64_t getmaxrss(void)
3858 {
3859 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3860     struct rusage rusage;
3861     getrusage(RUSAGE_SELF, &rusage);
3862     return (int64_t)rusage.ru_maxrss * 1024;
3863 #elif HAVE_GETPROCESSMEMORYINFO
3864     HANDLE proc;
3865     PROCESS_MEMORY_COUNTERS memcounters;
3866     proc = GetCurrentProcess();
3867     memcounters.cb = sizeof(memcounters);
3868     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3869     return memcounters.PeakPagefileUsage;
3870 #else
3871     return 0;
3872 #endif
3873 }
3874
3875 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3876 {
3877     int i;
3878     const char *p = str;
3879     for(i = 0;; i++) {
3880         dest[i] = atoi(p);
3881         if(i == 63)
3882             break;
3883         p = strchr(p, ',');
3884         if(!p) {
3885             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3886             ffmpeg_exit(1);
3887         }
3888         p++;
3889     }
3890 }
3891
3892 static void opt_inter_matrix(const char *arg)
3893 {
3894     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3895     parse_matrix_coeffs(inter_matrix, arg);
3896 }
3897
3898 static void opt_intra_matrix(const char *arg)
3899 {
3900     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3901     parse_matrix_coeffs(intra_matrix, arg);
3902 }
3903
3904 static void show_usage(void)
3905 {
3906     printf("Hyper fast Audio and Video encoder\n");
3907     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3908     printf("\n");
3909 }
3910
3911 static void show_help(void)
3912 {
3913     AVCodec *c;
3914     AVOutputFormat *oformat = NULL;
3915
3916     av_log_set_callback(log_callback_help);
3917     show_usage();
3918     show_help_options(options, "Main options:\n",
3919                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3920     show_help_options(options, "\nAdvanced options:\n",
3921                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3922                       OPT_EXPERT);
3923     show_help_options(options, "\nVideo options:\n",
3924                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925                       OPT_VIDEO);
3926     show_help_options(options, "\nAdvanced Video options:\n",
3927                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928                       OPT_VIDEO | OPT_EXPERT);
3929     show_help_options(options, "\nAudio options:\n",
3930                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931                       OPT_AUDIO);
3932     show_help_options(options, "\nAdvanced Audio options:\n",
3933                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3934                       OPT_AUDIO | OPT_EXPERT);
3935     show_help_options(options, "\nSubtitle options:\n",
3936                       OPT_SUBTITLE | OPT_GRAB,
3937                       OPT_SUBTITLE);
3938     show_help_options(options, "\nAudio/Video grab options:\n",
3939                       OPT_GRAB,
3940                       OPT_GRAB);
3941     printf("\n");
3942     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3943     printf("\n");
3944
3945     /* individual codec options */
3946     c = NULL;
3947     while ((c = av_codec_next(c))) {
3948         if (c->priv_class) {
3949             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3950             printf("\n");
3951         }
3952     }
3953
3954     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3955     printf("\n");
3956
3957     /* individual muxer options */
3958     while ((oformat = av_oformat_next(oformat))) {
3959         if (oformat->priv_class) {
3960             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3961             printf("\n");
3962         }
3963     }
3964
3965     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3966 }
3967
3968 static void opt_target(const char *arg)
3969 {
3970     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3971     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3972
3973     if(!strncmp(arg, "pal-", 4)) {
3974         norm = PAL;
3975         arg += 4;
3976     } else if(!strncmp(arg, "ntsc-", 5)) {
3977         norm = NTSC;
3978         arg += 5;
3979     } else if(!strncmp(arg, "film-", 5)) {
3980         norm = FILM;
3981         arg += 5;
3982     } else {
3983         int fr;
3984         /* Calculate FR via float to avoid int overflow */
3985         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3986         if(fr == 25000) {
3987             norm = PAL;
3988         } else if((fr == 29970) || (fr == 23976)) {
3989             norm = NTSC;
3990         } else {
3991             /* Try to determine PAL/NTSC by peeking in the input files */
3992             if(nb_input_files) {
3993                 int i, j;
3994                 for(j = 0; j < nb_input_files; j++) {
3995                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3996                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3997                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3998                             continue;
3999                         fr = c->time_base.den * 1000 / c->time_base.num;
4000                         if(fr == 25000) {
4001                             norm = PAL;
4002                             break;
4003                         } else if((fr == 29970) || (fr == 23976)) {
4004                             norm = NTSC;
4005                             break;
4006                         }
4007                     }
4008                     if(norm != UNKNOWN)
4009                         break;
4010                 }
4011             }
4012         }
4013         if(verbose > 0 && norm != UNKNOWN)
4014             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4015     }
4016
4017     if(norm == UNKNOWN) {
4018         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4019         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4020         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4021         ffmpeg_exit(1);
4022     }
4023
4024     if(!strcmp(arg, "vcd")) {
4025
4026         opt_video_codec("mpeg1video");
4027         opt_audio_codec("mp2");
4028         opt_format("vcd");
4029
4030         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4031         opt_frame_rate(NULL, frame_rates[norm]);
4032         opt_default("g", norm == PAL ? "15" : "18");
4033
4034         opt_default("b", "1150000");
4035         opt_default("maxrate", "1150000");
4036         opt_default("minrate", "1150000");
4037         opt_default("bufsize", "327680"); // 40*1024*8;
4038
4039         opt_default("ab", "224000");
4040         audio_sample_rate = 44100;
4041         audio_channels = 2;
4042
4043         opt_default("packetsize", "2324");
4044         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4045
4046         /* We have to offset the PTS, so that it is consistent with the SCR.
4047            SCR starts at 36000, but the first two packs contain only padding
4048            and the first pack from the other stream, respectively, may also have
4049            been written before.
4050            So the real data starts at SCR 36000+3*1200. */
4051         mux_preload= (36000+3*1200) / 90000.0; //0.44
4052     } else if(!strcmp(arg, "svcd")) {
4053
4054         opt_video_codec("mpeg2video");
4055         opt_audio_codec("mp2");
4056         opt_format("svcd");
4057
4058         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4059         opt_frame_rate(NULL, frame_rates[norm]);
4060         opt_default("g", norm == PAL ? "15" : "18");
4061
4062         opt_default("b", "2040000");
4063         opt_default("maxrate", "2516000");
4064         opt_default("minrate", "0"); //1145000;
4065         opt_default("bufsize", "1835008"); //224*1024*8;
4066         opt_default("flags", "+scan_offset");
4067
4068
4069         opt_default("ab", "224000");
4070         audio_sample_rate = 44100;
4071
4072         opt_default("packetsize", "2324");
4073
4074     } else if(!strcmp(arg, "dvd")) {
4075
4076         opt_video_codec("mpeg2video");
4077         opt_audio_codec("ac3");
4078         opt_format("dvd");
4079
4080         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4081         opt_frame_rate(NULL, frame_rates[norm]);
4082         opt_default("g", norm == PAL ? "15" : "18");
4083
4084         opt_default("b", "6000000");
4085         opt_default("maxrate", "9000000");
4086         opt_default("minrate", "0"); //1500000;
4087         opt_default("bufsize", "1835008"); //224*1024*8;
4088
4089         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4090         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4091
4092         opt_default("ab", "448000");
4093         audio_sample_rate = 48000;
4094
4095     } else if(!strncmp(arg, "dv", 2)) {
4096
4097         opt_format("dv");
4098
4099         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4100         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4101                           (norm == PAL ? "yuv420p" : "yuv411p"));
4102         opt_frame_rate(NULL, frame_rates[norm]);
4103
4104         audio_sample_rate = 48000;
4105         audio_channels = 2;
4106
4107     } else {
4108         fprintf(stderr, "Unknown target: %s\n", arg);
4109         ffmpeg_exit(1);
4110     }
4111 }
4112
4113 static void opt_vstats_file (const char *arg)
4114 {
4115     av_free (vstats_filename);
4116     vstats_filename=av_strdup (arg);
4117 }
4118
4119 static void opt_vstats (void)
4120 {
4121     char filename[40];
4122     time_t today2 = time(NULL);
4123     struct tm *today = localtime(&today2);
4124
4125     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4126              today->tm_sec);
4127     opt_vstats_file(filename);
4128 }
4129
4130 static int opt_bsf(const char *opt, const char *arg)
4131 {
4132     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4133     AVBitStreamFilterContext **bsfp;
4134
4135     if(!bsfc){
4136         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4137         ffmpeg_exit(1);
4138     }
4139
4140     bsfp= *opt == 'v' ? &video_bitstream_filters :
4141           *opt == 'a' ? &audio_bitstream_filters :
4142                         &subtitle_bitstream_filters;
4143     while(*bsfp)
4144         bsfp= &(*bsfp)->next;
4145
4146     *bsfp= bsfc;
4147
4148     return 0;
4149 }
4150
4151 static int opt_preset(const char *opt, const char *arg)
4152 {
4153     FILE *f=NULL;
4154     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4155     char *codec_name = *opt == 'v' ? video_codec_name :
4156                        *opt == 'a' ? audio_codec_name :
4157                                      subtitle_codec_name;
4158
4159     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4160         fprintf(stderr, "File for preset '%s' not found\n", arg);
4161         ffmpeg_exit(1);
4162     }
4163
4164     while(!feof(f)){
4165         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4166         if(line[0] == '#' && !e)
4167             continue;
4168         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4169         if(e){
4170             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4171             ffmpeg_exit(1);
4172         }
4173         if(!strcmp(tmp, "acodec")){
4174             opt_audio_codec(tmp2);
4175         }else if(!strcmp(tmp, "vcodec")){
4176             opt_video_codec(tmp2);
4177         }else if(!strcmp(tmp, "scodec")){
4178             opt_subtitle_codec(tmp2);
4179         }else if(!strcmp(tmp, "dcodec")){
4180             opt_data_codec(tmp2);
4181         }else if(opt_default(tmp, tmp2) < 0){
4182             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4183             ffmpeg_exit(1);
4184         }
4185     }
4186
4187     fclose(f);
4188
4189     return 0;
4190 }
4191
4192 static const OptionDef options[] = {
4193     /* main options */
4194 #include "cmdutils_common_opts.h"
4195     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4196     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4197     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4198     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4199     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4200       "outfile[,metadata]:infile[,metadata]" },
4201     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4202       "outfile[,metadata]:infile[,metadata]" },
4203     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4204     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4205     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4206     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4207     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4208     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4209     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4210     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4211     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4212     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4213       "add timings for benchmarking" },
4214     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4215     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4216       "dump each input packet" },
4217     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4218       "when dumping packets, also dump the payload" },
4219     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4220     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4221     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4222     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4223     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4224     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4225     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4226     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4227     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4228     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4229     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4230     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4231     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4232     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4233     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4234     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4235     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4236
4237     /* video options */
4238     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4239     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4240     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4241     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4242     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4243     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4244     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4245     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4246     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4247     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4248     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4249     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4250     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4251     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4252     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4253     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4254     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4255     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4256     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4257     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4258     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4259     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4260     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4261     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4262       "use same quantizer as source (implies VBR)" },
4263     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4264     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4265     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4266       "deinterlace pictures" },
4267     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4268     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4269     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4270 #if CONFIG_AVFILTER
4271     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4272 #endif
4273     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4274     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4275     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4276     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4277     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4278     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4279     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4280     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4281     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4282     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4283     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4284
4285     /* audio options */
4286     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4287     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4288     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4289     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4290     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4291     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4292     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4293     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4294     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4295     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4296     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4297     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4298
4299     /* subtitle options */
4300     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4301     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4302     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4303     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4304     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4305
4306     /* grab options */
4307     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4308     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4309     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4310
4311     /* muxer options */
4312     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4313     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4314
4315     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4316     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4317     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4318
4319     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4320     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4321     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4322     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4323     /* data codec support */
4324     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4325
4326     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4327     { NULL, },
4328 };
4329
4330 int main(int argc, char **argv)
4331 {
4332     int64_t ti;
4333
4334     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4335
4336     avcodec_register_all();
4337 #if CONFIG_AVDEVICE
4338     avdevice_register_all();
4339 #endif
4340 #if CONFIG_AVFILTER
4341     avfilter_register_all();
4342 #endif
4343     av_register_all();
4344
4345     avio_set_interrupt_cb(decode_interrupt_cb);
4346
4347     init_opts();
4348
4349     show_banner();
4350
4351     /* parse options */
4352     parse_options(argc, argv, options, opt_output_file);
4353
4354     if(nb_output_files <= 0 && nb_input_files == 0) {
4355         show_usage();
4356         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4357         ffmpeg_exit(1);
4358     }
4359
4360     /* file converter / grab */
4361     if (nb_output_files <= 0) {
4362         fprintf(stderr, "At least one output file must be specified\n");
4363         ffmpeg_exit(1);
4364     }
4365
4366     if (nb_input_files == 0) {
4367         fprintf(stderr, "At least one input file must be specified\n");
4368         ffmpeg_exit(1);
4369     }
4370
4371     ti = getutime();
4372     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4373                   stream_maps, nb_stream_maps) < 0)
4374         ffmpeg_exit(1);
4375     ti = getutime() - ti;
4376     if (do_benchmark) {
4377         int maxrss = getmaxrss() / 1024;
4378         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4379     }
4380
4381     return ffmpeg_exit(0);
4382 }