avconv.c

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