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