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