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

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