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