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