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

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