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

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