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