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