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