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

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