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