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

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