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