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

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