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

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