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