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