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