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 int opt_qscale(const char *opt, const char *arg)
2792 {
2793     video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2794     if (video_qscale == 0) {
2795         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2796         return AVERROR(EINVAL);
2797     }
2798     return 0;
2799 }
2800
2801 static int opt_top_field_first(const char *opt, const char *arg)
2802 {
2803     top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2804     return 0;
2805 }
2806
2807 static int opt_thread_count(const char *opt, const char *arg)
2808 {
2809     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2810 #if !HAVE_THREADS
2811     if (verbose >= 0)
2812         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2813 #endif
2814     return 0;
2815 }
2816
2817 static void opt_audio_sample_fmt(const char *arg)
2818 {
2819     if (strcmp(arg, "list")) {
2820         audio_sample_fmt = av_get_sample_fmt(arg);
2821         if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2822             av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2823             ffmpeg_exit(1);
2824         }
2825     } else {
2826         int i;
2827         char fmt_str[128];
2828         for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2829             printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2830         ffmpeg_exit(0);
2831     }
2832 }
2833
2834 static int opt_audio_rate(const char *opt, const char *arg)
2835 {
2836     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2837     return 0;
2838 }
2839
2840 static int opt_audio_channels(const char *opt, const char *arg)
2841 {
2842     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2843     return 0;
2844 }
2845
2846 static int opt_video_channel(const char *opt, const char *arg)
2847 {
2848     video_channel = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2849     return 0;
2850 }
2851
2852 static void opt_video_standard(const char *arg)
2853 {
2854     video_standard = av_strdup(arg);
2855 }
2856
2857 static void opt_codec(int *pstream_copy, char **pcodec_name,
2858                       int codec_type, const char *arg)
2859 {
2860     av_freep(pcodec_name);
2861     if (!strcmp(arg, "copy")) {
2862         *pstream_copy = 1;
2863     } else {
2864         *pcodec_name = av_strdup(arg);
2865     }
2866 }
2867
2868 static void opt_audio_codec(const char *arg)
2869 {
2870     opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2871 }
2872
2873 static void opt_video_codec(const char *arg)
2874 {
2875     opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2876 }
2877
2878 static void opt_subtitle_codec(const char *arg)
2879 {
2880     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2881 }
2882
2883 static void opt_data_codec(const char *arg)
2884 {
2885     opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2886 }
2887
2888 static int opt_codec_tag(const char *opt, const char *arg)
2889 {
2890     char *tail;
2891     uint32_t *codec_tag;
2892
2893     codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2894                 !strcmp(opt, "vtag") ? &video_codec_tag :
2895                 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2896     if (!codec_tag)
2897         return -1;
2898
2899     *codec_tag = strtol(arg, &tail, 0);
2900     if (!tail || *tail)
2901         *codec_tag = AV_RL32(arg);
2902
2903     return 0;
2904 }
2905
2906 static void opt_map(const char *arg)
2907 {
2908     AVStreamMap *m;
2909     char *p;
2910
2911     stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2912     m = &stream_maps[nb_stream_maps-1];
2913
2914     m->file_index = strtol(arg, &p, 0);
2915     if (*p)
2916         p++;
2917
2918     m->stream_index = strtol(p, &p, 0);
2919     if (*p) {
2920         p++;
2921         m->sync_file_index = strtol(p, &p, 0);
2922         if (*p)
2923             p++;
2924         m->sync_stream_index = strtol(p, &p, 0);
2925     } else {
2926         m->sync_file_index = m->file_index;
2927         m->sync_stream_index = m->stream_index;
2928     }
2929 }
2930
2931 static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2932 {
2933     *endptr = arg;
2934     if (*arg == ',') {
2935         *type = *(++arg);
2936         switch (*arg) {
2937         case 'g':
2938             break;
2939         case 's':
2940         case 'c':
2941         case 'p':
2942             *index = strtol(++arg, endptr, 0);
2943             break;
2944         default:
2945             fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2946             ffmpeg_exit(1);
2947         }
2948     } else
2949         *type = 'g';
2950 }
2951
2952 static void opt_map_metadata(const char *arg)
2953 {
2954     AVMetaDataMap *m, *m1;
2955     char *p;
2956
2957     meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2958                                 &nb_meta_data_maps, nb_meta_data_maps + 1);
2959
2960     m = &meta_data_maps[nb_meta_data_maps - 1][0];
2961     m->file = strtol(arg, &p, 0);
2962     parse_meta_type(p, &m->type, &m->index, &p);
2963     if (*p)
2964         p++;
2965
2966     m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
2967     m1->file = strtol(p, &p, 0);
2968     parse_meta_type(p, &m1->type, &m1->index, &p);
2969
2970     if (m->type == 'g' || m1->type == 'g')
2971         metadata_global_autocopy = 0;
2972     if (m->type == 's' || m1->type == 's')
2973         metadata_streams_autocopy = 0;
2974     if (m->type == 'c' || m1->type == 'c')
2975         metadata_chapters_autocopy = 0;
2976 }
2977
2978 static void opt_map_meta_data(const char *arg)
2979 {
2980     fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2981                     "Use -map_metadata instead.\n");
2982     opt_map_metadata(arg);
2983 }
2984
2985 static void opt_map_chapters(const char *arg)
2986 {
2987     AVChapterMap *c;
2988     char *p;
2989
2990     chapter_maps = grow_array(chapter_maps, sizeof(*chapter_maps), &nb_chapter_maps,
2991                               nb_chapter_maps + 1);
2992     c = &chapter_maps[nb_chapter_maps - 1];
2993     c->out_file = strtol(arg, &p, 0);
2994     if (*p)
2995         p++;
2996
2997     c->in_file = strtol(p, &p, 0);
2998 }
2999
3000 static void opt_input_ts_scale(const char *arg)
3001 {
3002     unsigned int stream;
3003     double scale;
3004     char *p;
3005
3006     stream = strtol(arg, &p, 0);
3007     if (*p)
3008         p++;
3009     scale= strtod(p, &p);
3010
3011     if(stream >= MAX_STREAMS)
3012         ffmpeg_exit(1);
3013
3014     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);
3015     input_files_ts_scale[nb_input_files][stream]= scale;
3016 }
3017
3018 static int opt_recording_time(const char *opt, const char *arg)
3019 {
3020     recording_time = parse_time_or_die(opt, arg, 1);
3021     return 0;
3022 }
3023
3024 static int opt_start_time(const char *opt, const char *arg)
3025 {
3026     start_time = parse_time_or_die(opt, arg, 1);
3027     return 0;
3028 }
3029
3030 static int opt_recording_timestamp(const char *opt, const char *arg)
3031 {
3032     recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
3033     return 0;
3034 }
3035
3036 static int opt_input_ts_offset(const char *opt, const char *arg)
3037 {
3038     input_ts_offset = parse_time_or_die(opt, arg, 1);
3039     return 0;
3040 }
3041
3042 static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict)
3043 {
3044     const char *codec_string = encoder ? "encoder" : "decoder";
3045     AVCodec *codec;
3046
3047     if(!name)
3048         return CODEC_ID_NONE;
3049     codec = encoder ?
3050         avcodec_find_encoder_by_name(name) :
3051         avcodec_find_decoder_by_name(name);
3052     if(!codec) {
3053         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3054         ffmpeg_exit(1);
3055     }
3056     if(codec->type != type) {
3057         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3058         ffmpeg_exit(1);
3059     }
3060     if(codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
3061        strict > FF_COMPLIANCE_EXPERIMENTAL) {
3062         fprintf(stderr, "%s '%s' is experimental and might produce bad "
3063                 "results.\nAdd '-strict experimental' if you want to use it.\n",
3064                 codec_string, codec->name);
3065         codec = encoder ?
3066             avcodec_find_encoder(codec->id) :
3067             avcodec_find_decoder(codec->id);
3068         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
3069             fprintf(stderr, "Or use the non experimental %s '%s'.\n",
3070                     codec_string, codec->name);
3071         ffmpeg_exit(1);
3072     }
3073     return codec->id;
3074 }
3075
3076 static void opt_input_file(const char *filename)
3077 {
3078     AVFormatContext *ic;
3079     AVFormatParameters params, *ap = &params;
3080     AVInputFormat *file_iformat = NULL;
3081     int err, i, ret, rfps, rfps_base;
3082     int64_t timestamp;
3083
3084     if (last_asked_format) {
3085         if (!(file_iformat = av_find_input_format(last_asked_format))) {
3086             fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3087             ffmpeg_exit(1);
3088         }
3089         last_asked_format = NULL;
3090     }
3091
3092     if (!strcmp(filename, "-"))
3093         filename = "pipe:";
3094
3095     using_stdin |= !strncmp(filename, "pipe:", 5) ||
3096                     !strcmp(filename, "/dev/stdin");
3097
3098     /* get default parameters from command line */
3099     ic = avformat_alloc_context();
3100     if (!ic) {
3101         print_error(filename, AVERROR(ENOMEM));
3102         ffmpeg_exit(1);
3103     }
3104
3105     memset(ap, 0, sizeof(*ap));
3106     ap->prealloced_context = 1;
3107     ap->sample_rate = audio_sample_rate;
3108     ap->channels = audio_channels;
3109     ap->time_base.den = frame_rate.num;
3110     ap->time_base.num = frame_rate.den;
3111     ap->width = frame_width;
3112     ap->height = frame_height;
3113     ap->pix_fmt = frame_pix_fmt;
3114    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
3115     ap->channel = video_channel;
3116     ap->standard = video_standard;
3117
3118     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM, NULL);
3119
3120     ic->video_codec_id   =
3121         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0,
3122                           avcodec_opts[AVMEDIA_TYPE_VIDEO   ]->strict_std_compliance);
3123     ic->audio_codec_id   =
3124         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0,
3125                           avcodec_opts[AVMEDIA_TYPE_AUDIO   ]->strict_std_compliance);
3126     ic->subtitle_codec_id=
3127         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0,
3128                           avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3129     ic->flags |= AVFMT_FLAG_NONBLOCK;
3130
3131     /* open the input file with generic libav function */
3132     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3133     if (err < 0) {
3134         print_error(filename, err);
3135         ffmpeg_exit(1);
3136     }
3137     if(opt_programid) {
3138         int i, j;
3139         int found=0;
3140         for(i=0; i<ic->nb_streams; i++){
3141             ic->streams[i]->discard= AVDISCARD_ALL;
3142         }
3143         for(i=0; i<ic->nb_programs; i++){
3144             AVProgram *p= ic->programs[i];
3145             if(p->id != opt_programid){
3146                 p->discard = AVDISCARD_ALL;
3147             }else{
3148                 found=1;
3149                 for(j=0; j<p->nb_stream_indexes; j++){
3150                     ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3151                 }
3152             }
3153         }
3154         if(!found){
3155             fprintf(stderr, "Specified program id not found\n");
3156             ffmpeg_exit(1);
3157         }
3158         opt_programid=0;
3159     }
3160
3161     ic->loop_input = loop_input;
3162
3163     /* If not enough info to get the stream parameters, we decode the
3164        first frames to get it. (used in mpeg case for example) */
3165     ret = av_find_stream_info(ic);
3166     if (ret < 0 && verbose >= 0) {
3167         fprintf(stderr, "%s: could not find codec parameters\n", filename);
3168         av_close_input_file(ic);
3169         ffmpeg_exit(1);
3170     }
3171
3172     timestamp = start_time;
3173     /* add the stream start time */
3174     if (ic->start_time != AV_NOPTS_VALUE)
3175         timestamp += ic->start_time;
3176
3177     /* if seeking requested, we execute it */
3178     if (start_time != 0) {
3179         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3180         if (ret < 0) {
3181             fprintf(stderr, "%s: could not seek to position %0.3f\n",
3182                     filename, (double)timestamp / AV_TIME_BASE);
3183         }
3184         /* reset seek info */
3185         start_time = 0;
3186     }
3187
3188     /* update the current parameters so that they match the one of the input stream */
3189     for(i=0;i<ic->nb_streams;i++) {
3190         AVStream *st = ic->streams[i];
3191         AVCodecContext *dec = st->codec;
3192         dec->thread_count = thread_count;
3193         input_codecs = grow_array(input_codecs, sizeof(*input_codecs), &nb_input_codecs, nb_input_codecs + 1);
3194         switch (dec->codec_type) {
3195         case AVMEDIA_TYPE_AUDIO:
3196             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(audio_codec_name);
3197             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]);
3198             channel_layout    = dec->channel_layout;
3199             audio_channels    = dec->channels;
3200             audio_sample_rate = dec->sample_rate;
3201             audio_sample_fmt  = dec->sample_fmt;
3202             if(audio_disable)
3203                 st->discard= AVDISCARD_ALL;
3204             /* Note that av_find_stream_info can add more streams, and we
3205              * currently have no chance of setting up lowres decoding
3206              * early enough for them. */
3207             if (dec->lowres)
3208                 audio_sample_rate >>= dec->lowres;
3209             break;
3210         case AVMEDIA_TYPE_VIDEO:
3211             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(video_codec_name);
3212             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]);
3213             frame_height = dec->height;
3214             frame_width  = dec->width;
3215             if(ic->streams[i]->sample_aspect_ratio.num)
3216                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
3217             else
3218                 frame_aspect_ratio=av_q2d(dec->sample_aspect_ratio);
3219             frame_aspect_ratio *= (float) dec->width / dec->height;
3220             frame_pix_fmt = dec->pix_fmt;
3221             rfps      = ic->streams[i]->r_frame_rate.num;
3222             rfps_base = ic->streams[i]->r_frame_rate.den;
3223             if (dec->lowres) {
3224                 dec->flags |= CODEC_FLAG_EMU_EDGE;
3225                 frame_height >>= dec->lowres;
3226                 frame_width  >>= dec->lowres;
3227                 dec->height = frame_height;
3228                 dec->width  = frame_width;
3229             }
3230             if(me_threshold)
3231                 dec->debug |= FF_DEBUG_MV;
3232
3233             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3234
3235                 if (verbose >= 0)
3236                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3237                             i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3238
3239                     (float)rfps / rfps_base, rfps, rfps_base);
3240             }
3241             /* update the current frame rate to match the stream frame rate */
3242             frame_rate.num = rfps;
3243             frame_rate.den = rfps_base;
3244
3245             if(video_disable)
3246                 st->discard= AVDISCARD_ALL;
3247             else if(video_discard)
3248                 st->discard= video_discard;
3249             break;
3250         case AVMEDIA_TYPE_DATA:
3251             break;
3252         case AVMEDIA_TYPE_SUBTITLE:
3253             input_codecs[nb_input_codecs-1] = avcodec_find_decoder_by_name(subtitle_codec_name);
3254             if(subtitle_disable)
3255                 st->discard = AVDISCARD_ALL;
3256             break;
3257         case AVMEDIA_TYPE_ATTACHMENT:
3258         case AVMEDIA_TYPE_UNKNOWN:
3259             break;
3260         default:
3261             abort();
3262         }
3263     }
3264
3265     input_files[nb_input_files] = ic;
3266     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3267     /* dump the file content */
3268     if (verbose >= 0)
3269         av_dump_format(ic, nb_input_files, filename, 0);
3270
3271     nb_input_files++;
3272
3273     video_channel = 0;
3274
3275     av_freep(&video_codec_name);
3276     av_freep(&audio_codec_name);
3277     av_freep(&subtitle_codec_name);
3278     uninit_opts();
3279     init_opts();
3280 }
3281
3282 static void check_inputs(int *has_video_ptr,
3283                          int *has_audio_ptr,
3284                          int *has_subtitle_ptr,
3285                          int *has_data_ptr)
3286 {
3287     int has_video, has_audio, has_subtitle, has_data, i, j;
3288     AVFormatContext *ic;
3289
3290     has_video = 0;
3291     has_audio = 0;
3292     has_subtitle = 0;
3293     has_data = 0;
3294
3295     for(j=0;j<nb_input_files;j++) {
3296         ic = input_files[j];
3297         for(i=0;i<ic->nb_streams;i++) {
3298             AVCodecContext *enc = ic->streams[i]->codec;
3299             switch(enc->codec_type) {
3300             case AVMEDIA_TYPE_AUDIO:
3301                 has_audio = 1;
3302                 break;
3303             case AVMEDIA_TYPE_VIDEO:
3304                 has_video = 1;
3305                 break;
3306             case AVMEDIA_TYPE_SUBTITLE:
3307                 has_subtitle = 1;
3308                 break;
3309             case AVMEDIA_TYPE_DATA:
3310             case AVMEDIA_TYPE_ATTACHMENT:
3311             case AVMEDIA_TYPE_UNKNOWN:
3312                 has_data = 1;
3313                 break;
3314             default:
3315                 abort();
3316             }
3317         }
3318     }
3319     *has_video_ptr = has_video;
3320     *has_audio_ptr = has_audio;
3321     *has_subtitle_ptr = has_subtitle;
3322     *has_data_ptr = has_data;
3323 }
3324
3325 static void new_video_stream(AVFormatContext *oc, int file_idx)
3326 {
3327     AVStream *st;
3328     AVOutputStream *ost;
3329     AVCodecContext *video_enc;
3330     enum CodecID codec_id = CODEC_ID_NONE;
3331     AVCodec *codec= NULL;
3332
3333     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3334     if (!st) {
3335         fprintf(stderr, "Could not alloc stream\n");
3336         ffmpeg_exit(1);
3337     }
3338     ost = new_output_stream(oc, file_idx);
3339
3340     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3341     if(!video_stream_copy){
3342         if (video_codec_name) {
3343             codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1,
3344                                          avcodec_opts[AVMEDIA_TYPE_VIDEO]->strict_std_compliance);
3345             codec = avcodec_find_encoder_by_name(video_codec_name);
3346             output_codecs[nb_output_codecs-1] = codec;
3347         } else {
3348             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3349             codec = avcodec_find_encoder(codec_id);
3350         }
3351     }
3352
3353     avcodec_get_context_defaults3(st->codec, codec);
3354     ost->bitstream_filters = video_bitstream_filters;
3355     video_bitstream_filters= NULL;
3356
3357     st->codec->thread_count= thread_count;
3358
3359     video_enc = st->codec;
3360
3361     if(video_codec_tag)
3362         video_enc->codec_tag= video_codec_tag;
3363
3364     if(   (video_global_header&1)
3365        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3366         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3367         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3368     }
3369     if(video_global_header&2){
3370         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3371         avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3372     }
3373
3374     if (video_stream_copy) {
3375         st->stream_copy = 1;
3376         video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3377         video_enc->sample_aspect_ratio =
3378         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3379     } else {
3380         const char *p;
3381         int i;
3382         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3383
3384         video_enc->codec_id = codec_id;
3385         set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3386
3387         if (codec && codec->supported_framerates && !force_fps)
3388             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3389         video_enc->time_base.den = fps.num;
3390         video_enc->time_base.num = fps.den;
3391
3392         video_enc->width = frame_width;
3393         video_enc->height = frame_height;
3394         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3395         video_enc->pix_fmt = frame_pix_fmt;
3396         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3397
3398         choose_pixel_fmt(st, codec);
3399
3400         if (intra_only)
3401             video_enc->gop_size = 0;
3402         if (video_qscale || same_quality) {
3403             video_enc->flags |= CODEC_FLAG_QSCALE;
3404             video_enc->global_quality=
3405                 st->quality = FF_QP2LAMBDA * video_qscale;
3406         }
3407
3408         if(intra_matrix)
3409             video_enc->intra_matrix = intra_matrix;
3410         if(inter_matrix)
3411             video_enc->inter_matrix = inter_matrix;
3412
3413         p= video_rc_override_string;
3414         for(i=0; p; i++){
3415             int start, end, q;
3416             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3417             if(e!=3){
3418                 fprintf(stderr, "error parsing rc_override\n");
3419                 ffmpeg_exit(1);
3420             }
3421             video_enc->rc_override=
3422                 av_realloc(video_enc->rc_override,
3423                            sizeof(RcOverride)*(i+1));
3424             video_enc->rc_override[i].start_frame= start;
3425             video_enc->rc_override[i].end_frame  = end;
3426             if(q>0){
3427                 video_enc->rc_override[i].qscale= q;
3428                 video_enc->rc_override[i].quality_factor= 1.0;
3429             }
3430             else{
3431                 video_enc->rc_override[i].qscale= 0;
3432                 video_enc->rc_override[i].quality_factor= -q/100.0;
3433             }
3434             p= strchr(p, '/');
3435             if(p) p++;
3436         }
3437         video_enc->rc_override_count=i;
3438         if (!video_enc->rc_initial_buffer_occupancy)
3439             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3440         video_enc->me_threshold= me_threshold;
3441         video_enc->intra_dc_precision= intra_dc_precision - 8;
3442
3443         if (do_psnr)
3444             video_enc->flags|= CODEC_FLAG_PSNR;
3445
3446         /* two pass mode */
3447         if (do_pass) {
3448             if (do_pass == 1) {
3449                 video_enc->flags |= CODEC_FLAG_PASS1;
3450             } else {
3451                 video_enc->flags |= CODEC_FLAG_PASS2;
3452             }
3453         }
3454
3455         if (forced_key_frames)
3456             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3457     }
3458     if (video_language) {
3459         av_metadata_set2(&st->metadata, "language", video_language, 0);
3460         av_freep(&video_language);
3461     }
3462
3463     /* reset some key parameters */
3464     video_disable = 0;
3465     av_freep(&video_codec_name);
3466     av_freep(&forced_key_frames);
3467     video_stream_copy = 0;
3468     frame_pix_fmt = PIX_FMT_NONE;
3469 }
3470
3471 static void new_audio_stream(AVFormatContext *oc, int file_idx)
3472 {
3473     AVStream *st;
3474     AVOutputStream *ost;
3475     AVCodec *codec= NULL;
3476     AVCodecContext *audio_enc;
3477     enum CodecID codec_id = CODEC_ID_NONE;
3478
3479     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3480     if (!st) {
3481         fprintf(stderr, "Could not alloc stream\n");
3482         ffmpeg_exit(1);
3483     }
3484     ost = new_output_stream(oc, file_idx);
3485
3486     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3487     if(!audio_stream_copy){
3488         if (audio_codec_name) {
3489             codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1,
3490                                          avcodec_opts[AVMEDIA_TYPE_AUDIO]->strict_std_compliance);
3491             codec = avcodec_find_encoder_by_name(audio_codec_name);
3492             output_codecs[nb_output_codecs-1] = codec;
3493         } else {
3494             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3495             codec = avcodec_find_encoder(codec_id);
3496         }
3497     }
3498
3499     avcodec_get_context_defaults3(st->codec, codec);
3500
3501     ost->bitstream_filters = audio_bitstream_filters;
3502     audio_bitstream_filters= NULL;
3503
3504     st->codec->thread_count= thread_count;
3505
3506     audio_enc = st->codec;
3507     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3508
3509     if(audio_codec_tag)
3510         audio_enc->codec_tag= audio_codec_tag;
3511
3512     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3513         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3514         avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3515     }
3516     if (audio_stream_copy) {
3517         st->stream_copy = 1;
3518         audio_enc->channels = audio_channels;
3519         audio_enc->sample_rate = audio_sample_rate;
3520     } else {
3521         audio_enc->codec_id = codec_id;
3522         set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3523
3524         if (audio_qscale > QSCALE_NONE) {
3525             audio_enc->flags |= CODEC_FLAG_QSCALE;
3526             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3527         }
3528         audio_enc->channels = audio_channels;
3529         audio_enc->sample_fmt = audio_sample_fmt;
3530         audio_enc->sample_rate = audio_sample_rate;
3531         audio_enc->channel_layout = channel_layout;
3532         if (av_get_channel_layout_nb_channels(channel_layout) != audio_channels)
3533             audio_enc->channel_layout = 0;
3534         choose_sample_fmt(st, codec);
3535         choose_sample_rate(st, codec);
3536     }
3537     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3538     if (audio_language) {
3539         av_metadata_set2(&st->metadata, "language", audio_language, 0);
3540         av_freep(&audio_language);
3541     }
3542
3543     /* reset some key parameters */
3544     audio_disable = 0;
3545     av_freep(&audio_codec_name);
3546     audio_stream_copy = 0;
3547 }
3548
3549 static void new_data_stream(AVFormatContext *oc, int file_idx)
3550 {
3551     AVStream *st;
3552     AVOutputStream *ost;
3553     AVCodec *codec=NULL;
3554     AVCodecContext *data_enc;
3555
3556     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3557     if (!st) {
3558         fprintf(stderr, "Could not alloc stream\n");
3559         ffmpeg_exit(1);
3560     }
3561     ost = new_output_stream(oc, file_idx);
3562     data_enc = st->codec;
3563     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3564     if (!data_stream_copy) {
3565         fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3566         ffmpeg_exit(1);
3567     }
3568     avcodec_get_context_defaults3(st->codec, codec);
3569
3570     data_enc->codec_type = AVMEDIA_TYPE_DATA;
3571
3572     if (data_codec_tag)
3573         data_enc->codec_tag= data_codec_tag;
3574
3575     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3576         data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3577         avcodec_opts[AVMEDIA_TYPE_DATA]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3578     }
3579     if (data_stream_copy) {
3580         st->stream_copy = 1;
3581     }
3582
3583     data_disable = 0;
3584     av_freep(&data_codec_name);
3585     data_stream_copy = 0;
3586 }
3587
3588 static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3589 {
3590     AVStream *st;
3591     AVOutputStream *ost;
3592     AVCodec *codec=NULL;
3593     AVCodecContext *subtitle_enc;
3594     enum CodecID codec_id = CODEC_ID_NONE;
3595
3596     st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3597     if (!st) {
3598         fprintf(stderr, "Could not alloc stream\n");
3599         ffmpeg_exit(1);
3600     }
3601     ost = new_output_stream(oc, file_idx);
3602     subtitle_enc = st->codec;
3603     output_codecs = grow_array(output_codecs, sizeof(*output_codecs), &nb_output_codecs, nb_output_codecs + 1);
3604     if(!subtitle_stream_copy){
3605         if (subtitle_codec_name) {
3606             codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1,
3607                                          avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance);
3608             codec= output_codecs[nb_output_codecs-1] = avcodec_find_encoder_by_name(subtitle_codec_name);
3609         } else {
3610             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3611             codec = avcodec_find_encoder(codec_id);
3612         }
3613     }
3614     avcodec_get_context_defaults3(st->codec, codec);
3615
3616     ost->bitstream_filters = subtitle_bitstream_filters;
3617     subtitle_bitstream_filters= NULL;
3618
3619     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3620
3621     if(subtitle_codec_tag)
3622         subtitle_enc->codec_tag= subtitle_codec_tag;
3623
3624     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3625         subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3626         avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->flags |= CODEC_FLAG_GLOBAL_HEADER;
3627     }
3628     if (subtitle_stream_copy) {
3629         st->stream_copy = 1;
3630     } else {
3631         subtitle_enc->codec_id = codec_id;
3632         set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM, codec);
3633     }
3634
3635     if (subtitle_language) {
3636         av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
3637         av_freep(&subtitle_language);
3638     }
3639
3640     subtitle_disable = 0;
3641     av_freep(&subtitle_codec_name);
3642     subtitle_stream_copy = 0;
3643 }
3644
3645 static int opt_new_stream(const char *opt, const char *arg)
3646 {
3647     AVFormatContext *oc;
3648     int file_idx = nb_output_files - 1;
3649     if (nb_output_files <= 0) {
3650         fprintf(stderr, "At least one output file must be specified\n");
3651         ffmpeg_exit(1);
3652     }
3653     oc = output_files[file_idx];
3654
3655     if      (!strcmp(opt, "newvideo"   )) new_video_stream   (oc, file_idx);
3656     else if (!strcmp(opt, "newaudio"   )) new_audio_stream   (oc, file_idx);
3657     else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3658     else if (!strcmp(opt, "newdata"    )) new_data_stream    (oc, file_idx);
3659     else av_assert0(0);
3660     return 0;
3661 }
3662
3663 /* arg format is "output-stream-index:streamid-value". */
3664 static int opt_streamid(const char *opt, const char *arg)
3665 {
3666     int idx;
3667     char *p;
3668     char idx_str[16];
3669
3670     av_strlcpy(idx_str, arg, sizeof(idx_str));
3671     p = strchr(idx_str, ':');
3672     if (!p) {
3673         fprintf(stderr,
3674                 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3675                 arg, opt);
3676         ffmpeg_exit(1);
3677     }
3678     *p++ = '\0';
3679     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3680     streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3681     streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3682     return 0;
3683 }
3684
3685 static void opt_output_file(const char *filename)
3686 {
3687     AVFormatContext *oc;
3688     int err, use_video, use_audio, use_subtitle, use_data;
3689     int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3690     AVFormatParameters params, *ap = &params;
3691     AVOutputFormat *file_oformat;
3692
3693     if (!strcmp(filename, "-"))
3694         filename = "pipe:";
3695
3696     oc = avformat_alloc_context();
3697     if (!oc) {
3698         print_error(filename, AVERROR(ENOMEM));
3699         ffmpeg_exit(1);
3700     }
3701
3702     if (last_asked_format) {
3703         file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3704         if (!file_oformat) {
3705             fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3706             ffmpeg_exit(1);
3707         }
3708         last_asked_format = NULL;
3709     } else {
3710         file_oformat = av_guess_format(NULL, filename, NULL);
3711         if (!file_oformat) {
3712             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3713                     filename);
3714             ffmpeg_exit(1);
3715         }
3716     }
3717
3718     oc->oformat = file_oformat;
3719     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3720
3721     if (!strcmp(file_oformat->name, "ffm") &&
3722         av_strstart(filename, "http:", NULL)) {
3723         /* special case for files sent to ffserver: we get the stream
3724            parameters from ffserver */
3725         int err = read_ffserver_streams(oc, filename);
3726         if (err < 0) {
3727             print_error(filename, err);
3728             ffmpeg_exit(1);
3729         }
3730     } else {
3731         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3732         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3733         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3734         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 */
3735
3736         /* disable if no corresponding type found and at least one
3737            input file */
3738         if (nb_input_files > 0) {
3739             check_inputs(&input_has_video,
3740                          &input_has_audio,
3741                          &input_has_subtitle,
3742                          &input_has_data);
3743
3744             if (!input_has_video)
3745                 use_video = 0;
3746             if (!input_has_audio)
3747                 use_audio = 0;
3748             if (!input_has_subtitle)
3749                 use_subtitle = 0;
3750             if (!input_has_data)
3751                 use_data = 0;
3752         }
3753
3754         /* manual disable */
3755         if (audio_disable)    use_audio    = 0;
3756         if (video_disable)    use_video    = 0;
3757         if (subtitle_disable) use_subtitle = 0;
3758         if (data_disable)     use_data     = 0;
3759
3760         if (use_video)    new_video_stream(oc, nb_output_files);
3761         if (use_audio)    new_audio_stream(oc, nb_output_files);
3762         if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3763         if (use_data)     new_data_stream(oc, nb_output_files);
3764
3765         oc->timestamp = recording_timestamp;
3766
3767         av_metadata_copy(&oc->metadata, metadata, 0);
3768         av_metadata_free(&metadata);
3769     }
3770
3771     output_files[nb_output_files++] = oc;
3772
3773     /* check filename in case of an image number is expected */
3774     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3775         if (!av_filename_number_test(oc->filename)) {
3776             print_error(oc->filename, AVERROR(EINVAL));
3777             ffmpeg_exit(1);
3778         }
3779     }
3780
3781     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3782         /* test if it already exists to avoid loosing precious files */
3783         if (!file_overwrite &&
3784             (strchr(filename, ':') == NULL ||
3785              filename[1] == ':' ||
3786              av_strstart(filename, "file:", NULL))) {
3787             if (avio_check(filename, 0) == 0) {
3788                 if (!using_stdin) {
3789                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3790                     fflush(stderr);
3791                     if (!read_yesno()) {
3792                         fprintf(stderr, "Not overwriting - exiting\n");
3793                         ffmpeg_exit(1);
3794                     }
3795                 }
3796                 else {
3797                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3798                     ffmpeg_exit(1);
3799                 }
3800             }
3801         }
3802
3803         /* open the file */
3804         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3805             print_error(filename, err);
3806             ffmpeg_exit(1);
3807         }
3808     }
3809
3810     memset(ap, 0, sizeof(*ap));
3811     if (av_set_parameters(oc, ap) < 0) {
3812         fprintf(stderr, "%s: Invalid encoding parameters\n",
3813                 oc->filename);
3814         ffmpeg_exit(1);
3815     }
3816
3817     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3818     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3819     oc->loop_output = loop_output;
3820     oc->flags |= AVFMT_FLAG_NONBLOCK;
3821
3822     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM, NULL);
3823
3824     av_freep(&forced_key_frames);
3825     uninit_opts();
3826     init_opts();
3827 }
3828
3829 /* same option as mencoder */
3830 static int opt_pass(const char *opt, const char *arg)
3831 {
3832     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3833     return 0;
3834 }
3835
3836 static int64_t getutime(void)
3837 {
3838 #if HAVE_GETRUSAGE
3839     struct rusage rusage;
3840
3841     getrusage(RUSAGE_SELF, &rusage);
3842     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3843 #elif HAVE_GETPROCESSTIMES
3844     HANDLE proc;
3845     FILETIME c, e, k, u;
3846     proc = GetCurrentProcess();
3847     GetProcessTimes(proc, &c, &e, &k, &u);
3848     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3849 #else
3850     return av_gettime();
3851 #endif
3852 }
3853
3854 static int64_t getmaxrss(void)
3855 {
3856 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3857     struct rusage rusage;
3858     getrusage(RUSAGE_SELF, &rusage);
3859     return (int64_t)rusage.ru_maxrss * 1024;
3860 #elif HAVE_GETPROCESSMEMORYINFO
3861     HANDLE proc;
3862     PROCESS_MEMORY_COUNTERS memcounters;
3863     proc = GetCurrentProcess();
3864     memcounters.cb = sizeof(memcounters);
3865     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3866     return memcounters.PeakPagefileUsage;
3867 #else
3868     return 0;
3869 #endif
3870 }
3871
3872 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3873 {
3874     int i;
3875     const char *p = str;
3876     for(i = 0;; i++) {
3877         dest[i] = atoi(p);
3878         if(i == 63)
3879             break;
3880         p = strchr(p, ',');
3881         if(!p) {
3882             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3883             ffmpeg_exit(1);
3884         }
3885         p++;
3886     }
3887 }
3888
3889 static void opt_inter_matrix(const char *arg)
3890 {
3891     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3892     parse_matrix_coeffs(inter_matrix, arg);
3893 }
3894
3895 static void opt_intra_matrix(const char *arg)
3896 {
3897     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3898     parse_matrix_coeffs(intra_matrix, arg);
3899 }
3900
3901 static void show_usage(void)
3902 {
3903     printf("Hyper fast Audio and Video encoder\n");
3904     printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3905     printf("\n");
3906 }
3907
3908 static void show_help(void)
3909 {
3910     AVCodec *c;
3911     AVOutputFormat *oformat = NULL;
3912
3913     av_log_set_callback(log_callback_help);
3914     show_usage();
3915     show_help_options(options, "Main options:\n",
3916                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3917     show_help_options(options, "\nAdvanced options:\n",
3918                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3919                       OPT_EXPERT);
3920     show_help_options(options, "\nVideo options:\n",
3921                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922                       OPT_VIDEO);
3923     show_help_options(options, "\nAdvanced Video options:\n",
3924                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3925                       OPT_VIDEO | OPT_EXPERT);
3926     show_help_options(options, "\nAudio options:\n",
3927                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3928                       OPT_AUDIO);
3929     show_help_options(options, "\nAdvanced Audio options:\n",
3930                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3931                       OPT_AUDIO | OPT_EXPERT);
3932     show_help_options(options, "\nSubtitle options:\n",
3933                       OPT_SUBTITLE | OPT_GRAB,
3934                       OPT_SUBTITLE);
3935     show_help_options(options, "\nAudio/Video grab options:\n",
3936                       OPT_GRAB,
3937                       OPT_GRAB);
3938     printf("\n");
3939     av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3940     printf("\n");
3941
3942     /* individual codec options */
3943     c = NULL;
3944     while ((c = av_codec_next(c))) {
3945         if (c->priv_class) {
3946             av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3947             printf("\n");
3948         }
3949     }
3950
3951     av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3952     printf("\n");
3953
3954     /* individual muxer options */
3955     while ((oformat = av_oformat_next(oformat))) {
3956         if (oformat->priv_class) {
3957             av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3958             printf("\n");
3959         }
3960     }
3961
3962     av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3963 }
3964
3965 static void opt_target(const char *arg)
3966 {
3967     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3968     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3969
3970     if(!strncmp(arg, "pal-", 4)) {
3971         norm = PAL;
3972         arg += 4;
3973     } else if(!strncmp(arg, "ntsc-", 5)) {
3974         norm = NTSC;
3975         arg += 5;
3976     } else if(!strncmp(arg, "film-", 5)) {
3977         norm = FILM;
3978         arg += 5;
3979     } else {
3980         int fr;
3981         /* Calculate FR via float to avoid int overflow */
3982         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3983         if(fr == 25000) {
3984             norm = PAL;
3985         } else if((fr == 29970) || (fr == 23976)) {
3986             norm = NTSC;
3987         } else {
3988             /* Try to determine PAL/NTSC by peeking in the input files */
3989             if(nb_input_files) {
3990                 int i, j;
3991                 for(j = 0; j < nb_input_files; j++) {
3992                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3993                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3994                         if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3995                             continue;
3996                         fr = c->time_base.den * 1000 / c->time_base.num;
3997                         if(fr == 25000) {
3998                             norm = PAL;
3999                             break;
4000                         } else if((fr == 29970) || (fr == 23976)) {
4001                             norm = NTSC;
4002                             break;
4003                         }
4004                     }
4005                     if(norm != UNKNOWN)
4006                         break;
4007                 }
4008             }
4009         }
4010         if(verbose > 0 && norm != UNKNOWN)
4011             fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4012     }
4013
4014     if(norm == UNKNOWN) {
4015         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4016         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4017         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4018         ffmpeg_exit(1);
4019     }
4020
4021     if(!strcmp(arg, "vcd")) {
4022
4023         opt_video_codec("mpeg1video");
4024         opt_audio_codec("mp2");
4025         opt_format("vcd");
4026
4027         opt_frame_size(norm == PAL ? "352x288" : "352x240");
4028         opt_frame_rate(NULL, frame_rates[norm]);
4029         opt_default("g", norm == PAL ? "15" : "18");
4030
4031         opt_default("b", "1150000");
4032         opt_default("maxrate", "1150000");
4033         opt_default("minrate", "1150000");
4034         opt_default("bufsize", "327680"); // 40*1024*8;
4035
4036         opt_default("ab", "224000");
4037         audio_sample_rate = 44100;
4038         audio_channels = 2;
4039
4040         opt_default("packetsize", "2324");
4041         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4042
4043         /* We have to offset the PTS, so that it is consistent with the SCR.
4044            SCR starts at 36000, but the first two packs contain only padding
4045            and the first pack from the other stream, respectively, may also have
4046            been written before.
4047            So the real data starts at SCR 36000+3*1200. */
4048         mux_preload= (36000+3*1200) / 90000.0; //0.44
4049     } else if(!strcmp(arg, "svcd")) {
4050
4051         opt_video_codec("mpeg2video");
4052         opt_audio_codec("mp2");
4053         opt_format("svcd");
4054
4055         opt_frame_size(norm == PAL ? "480x576" : "480x480");
4056         opt_frame_rate(NULL, frame_rates[norm]);
4057         opt_default("g", norm == PAL ? "15" : "18");
4058
4059         opt_default("b", "2040000");
4060         opt_default("maxrate", "2516000");
4061         opt_default("minrate", "0"); //1145000;
4062         opt_default("bufsize", "1835008"); //224*1024*8;
4063         opt_default("flags", "+scan_offset");
4064
4065
4066         opt_default("ab", "224000");
4067         audio_sample_rate = 44100;
4068
4069         opt_default("packetsize", "2324");
4070
4071     } else if(!strcmp(arg, "dvd")) {
4072
4073         opt_video_codec("mpeg2video");
4074         opt_audio_codec("ac3");
4075         opt_format("dvd");
4076
4077         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4078         opt_frame_rate(NULL, frame_rates[norm]);
4079         opt_default("g", norm == PAL ? "15" : "18");
4080
4081         opt_default("b", "6000000");
4082         opt_default("maxrate", "9000000");
4083         opt_default("minrate", "0"); //1500000;
4084         opt_default("bufsize", "1835008"); //224*1024*8;
4085
4086         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4087         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4088
4089         opt_default("ab", "448000");
4090         audio_sample_rate = 48000;
4091
4092     } else if(!strncmp(arg, "dv", 2)) {
4093
4094         opt_format("dv");
4095
4096         opt_frame_size(norm == PAL ? "720x576" : "720x480");
4097         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
4098                           (norm == PAL ? "yuv420p" : "yuv411p"));
4099         opt_frame_rate(NULL, frame_rates[norm]);
4100
4101         audio_sample_rate = 48000;
4102         audio_channels = 2;
4103
4104     } else {
4105         fprintf(stderr, "Unknown target: %s\n", arg);
4106         ffmpeg_exit(1);
4107     }
4108 }
4109
4110 static void opt_vstats_file (const char *arg)
4111 {
4112     av_free (vstats_filename);
4113     vstats_filename=av_strdup (arg);
4114 }
4115
4116 static void opt_vstats (void)
4117 {
4118     char filename[40];
4119     time_t today2 = time(NULL);
4120     struct tm *today = localtime(&today2);
4121
4122     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4123              today->tm_sec);
4124     opt_vstats_file(filename);
4125 }
4126
4127 static int opt_bsf(const char *opt, const char *arg)
4128 {
4129     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4130     AVBitStreamFilterContext **bsfp;
4131
4132     if(!bsfc){
4133         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4134         ffmpeg_exit(1);
4135     }
4136
4137     bsfp= *opt == 'v' ? &video_bitstream_filters :
4138           *opt == 'a' ? &audio_bitstream_filters :
4139                         &subtitle_bitstream_filters;
4140     while(*bsfp)
4141         bsfp= &(*bsfp)->next;
4142
4143     *bsfp= bsfc;
4144
4145     return 0;
4146 }
4147
4148 static int opt_preset(const char *opt, const char *arg)
4149 {
4150     FILE *f=NULL;
4151     char filename[1000], tmp[1000], tmp2[1000], line[1000];
4152     char *codec_name = *opt == 'v' ? video_codec_name :
4153                        *opt == 'a' ? audio_codec_name :
4154                                      subtitle_codec_name;
4155
4156     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4157         fprintf(stderr, "File for preset '%s' not found\n", arg);
4158         ffmpeg_exit(1);
4159     }
4160
4161     while(!feof(f)){
4162         int e= fscanf(f, "%999[^\n]\n", line) - 1;
4163         if(line[0] == '#' && !e)
4164             continue;
4165         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4166         if(e){
4167             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4168             ffmpeg_exit(1);
4169         }
4170         if(!strcmp(tmp, "acodec")){
4171             opt_audio_codec(tmp2);
4172         }else if(!strcmp(tmp, "vcodec")){
4173             opt_video_codec(tmp2);
4174         }else if(!strcmp(tmp, "scodec")){
4175             opt_subtitle_codec(tmp2);
4176         }else if(!strcmp(tmp, "dcodec")){
4177             opt_data_codec(tmp2);
4178         }else if(opt_default(tmp, tmp2) < 0){
4179             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4180             ffmpeg_exit(1);
4181         }
4182     }
4183
4184     fclose(f);
4185
4186     return 0;
4187 }
4188
4189 static const OptionDef options[] = {
4190     /* main options */
4191 #include "cmdutils_common_opts.h"
4192     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4193     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4194     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4195     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4196     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4197       "outfile[,metadata]:infile[,metadata]" },
4198     { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4199       "outfile[,metadata]:infile[,metadata]" },
4200     { "map_chapters",  HAS_ARG | OPT_EXPERT, {(void*)opt_map_chapters},  "set chapters mapping", "outfile:infile" },
4201     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4202     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4203     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4204     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4205     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
4206     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4207     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4208     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4209     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4210       "add timings for benchmarking" },
4211     { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4212     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4213       "dump each input packet" },
4214     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4215       "when dumping packets, also dump the payload" },
4216     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4217     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4218     { "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)", "" },
4219     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
4220     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4221     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4222     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4223     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4224     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4225     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4226     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4227     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4228     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4229     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4230     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4231     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4232     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4233
4234     /* video options */
4235     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4236     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4237     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4238     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4239     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4240     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4241     { "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" },
4242     { "croptop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4243     { "cropbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4244     { "cropleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4245     { "cropright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4246     { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4247     { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4248     { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4249     { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4250     { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4251     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4252     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4253     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4254     { "qscale", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4255     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4256     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4257     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
4258     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4259       "use same quantizer as source (implies VBR)" },
4260     { "pass", HAS_ARG | OPT_FUNC2 | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4261     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4262     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4263       "deinterlace pictures" },
4264     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4265     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4266     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4267 #if CONFIG_AVFILTER
4268     { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4269 #endif
4270     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4271     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4272     { "top", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4273     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4274     { "vtag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4275     { "newvideo", OPT_VIDEO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new video stream to the current output stream" },
4276     { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4277     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4278     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4279     { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4280     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4281
4282     /* audio options */
4283     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
4284     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4285     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4286     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4287     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4288     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4289     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4290     { "atag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4291     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4292     { "newaudio", OPT_AUDIO | OPT_FUNC2, {(void*)opt_new_stream}, "add a new audio stream to the current output stream" },
4293     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4294     { "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" },
4295
4296     /* subtitle options */
4297     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4298     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4299     { "newsubtitle", OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_new_stream}, "add a new subtitle stream to the current output stream" },
4300     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4301     { "stag", OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4302
4303     /* grab options */
4304     { "vc", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4305     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4306     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4307
4308     /* muxer options */
4309     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4310     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4311
4312     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4313     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4314     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4315
4316     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4317     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4318     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4319     { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4320     /* data codec support */
4321     { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4322
4323     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4324     { NULL, },
4325 };
4326
4327 int main(int argc, char **argv)
4328 {
4329     int64_t ti;
4330
4331     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4332
4333     avcodec_register_all();
4334 #if CONFIG_AVDEVICE
4335     avdevice_register_all();
4336 #endif
4337 #if CONFIG_AVFILTER
4338     avfilter_register_all();
4339 #endif
4340     av_register_all();
4341
4342     avio_set_interrupt_cb(decode_interrupt_cb);
4343
4344     init_opts();
4345
4346     show_banner();
4347
4348     /* parse options */
4349     parse_options(argc, argv, options, opt_output_file);
4350
4351     if(nb_output_files <= 0 && nb_input_files == 0) {
4352         show_usage();
4353         fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4354         ffmpeg_exit(1);
4355     }
4356
4357     /* file converter / grab */
4358     if (nb_output_files <= 0) {
4359         fprintf(stderr, "At least one output file must be specified\n");
4360         ffmpeg_exit(1);
4361     }
4362
4363     if (nb_input_files == 0) {
4364         fprintf(stderr, "At least one input file must be specified\n");
4365         ffmpeg_exit(1);
4366     }
4367
4368     ti = getutime();
4369     if (transcode(output_files, nb_output_files, input_files, nb_input_files,
4370                   stream_maps, nb_stream_maps) < 0)
4371         ffmpeg_exit(1);
4372     ti = getutime() - ti;
4373     if (do_benchmark) {
4374         int maxrss = getmaxrss() / 1024;
4375         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4376     }
4377
4378     return ffmpeg_exit(0);
4379 }