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

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