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